Mikrocontroller.net - Benutzerbeiträge [de]

IRMP

2021-02-03T06:20:01Z

Kichi:

Von '''Frank M. ([http://www.mikrocontroller.net/user/show/ukw ukw])'''

[[Datei:irmp-title.png| |Scan eines NEC-kompatiblen Fernbedienungssignals]]

'''[[IRMP_-_english#top|You will find the English documentation here.]]'''

Da RC5 nicht nur veraltet, sondern mittlerweile obsolet ist und immer mehr die elektronischen Geräte der fernöstlichen Unterhaltungsindustrie in unseren Haushalten Einzug finden, ist es an der Zeit, einen IR-Decoder zu entwickeln, der ca. 90% aller bei uns im täglichen Leben zu findenden IR-Fernbedienungen "versteht".

Im folgenden wird IRMP als "Infrarot-Multiprotokoll-Decoder" in allen Einzelheiten vorgestellt. Das Gegenstück, nämlich '''[[IRSND]]''' als IR-Encoder, wird in einem gesonderten [[IRSND|Artikel]] behandelt.

= IRMP - Infrarot-Multiprotokoll-Decoder =

[[Datei:irmp-empfaenger.png|miniatur|Anschluß eines IR-Empfängers an µC]]

=== Unterstützte µCs ===

[[IRMP#top|IRMP]] ist auf verschiedenen Mikrocontroller-Familien lauffähig.

'''AVR'''

* ATtiny87, ATtiny167
* ATtiny45, ATtiny85
* ATtiny44, ATtiny84
* ATmega8, ATmega16, ATmega32
* ATmega162
* ATmega164, ATmega324, ATmega644, ATmega644P, ATmega1284
* ATmega88, ATmega88P, ATmega168, ATmega168P, ATmega328P

'''XMega'''

* ATXmega128

'''PIC''' (CCS- und XC8/C18-Compiler)

* PIC12F1840
* PIC18F4520

'''STM32'''

* STM32F4xx (getestet auf STM32F401RE/F411RE Nucleo, STM32F4 Discovery)
* STM32F10x (getestet auf STM32F103C8T6 Mini Development Board)
* STM32 mit HAL-Library '''(NEU!)'''

'''STM8'''

* STM8S103F3

'''TI Stellaris'''

* LM4F120 Launchpad (ARM Cortex M4)

'''ESP8266 (NEU!)'''

* ESP8266-EVB

'''TEENSY 3.0 (NEU!)'''

* MK20DX256VLH7 (ARM Cortex-M4 72MHz)

'''MBED (NEU!)'''

* LPC1347 Cortex-M3 mit 72 MHz
* LPC4088 (Embedded Artists)

'''ChibiOS HAL (NEU!)'''

* Verschiedene ARM-Cortex-µCs, wie z.B. STM32, Kinetis, NRF5 etc.
* [https://sourceforge.net/p/chibios/svn2/HEAD/tree/trunk/os/hal/ports/ Offiziell unterstützte µC-Serien]
* [https://github.com/ChibiOS/ChibiOS-Contrib/tree/master/os/hal/ports weitere µC-Serien, von der Community unterstützt]

=== Unterstützte IR-Protokolle ===

[[IRMP#top|IRMP]] - der Infrarot-Fernbedienungsdecoder, der mehrere Protokolle auf einmal decodieren kann, beherrscht folgende Protokolle (in alphabetischer Reihenfolge):

{| {{Tabelle}}
|+ '''Unterstützte IR-Protokolle'''
|- style="background-color:#eeeeee"
! style="width:15%" | Protokoll
! style="width:100em" | Hersteller
|-
| [[IRMP#A1TVBOX|A1TVBOX]] || ADB (Advanced Digital Broadcast), z.B. A1 TV Box
|-
| [[IRMP#APPLE|APPLE]] || Apple
|-
| [[IRMP#ACP24|ACP24]] || Stiebel Eltron
|-
| [[IRMP#B&O|B&O]] || Bang & Olufsen
|-
| [[IRMP#BOSE|BOSE]] || Bose
|-
| [[IRMP#DENON|DENON]] || Denon, Sharp
|-
| [[IRMP#FAN|FAN]] || FAN, Fernsteuerung für Ventilatoren
|-
| [[IRMP#FDC|FDC]] || FDC Keyboard
|-
| [[IRMP#GRUNDIG_+_NOKIA|GRUNDIG]] || Grundig
|-
| [[IRMP#GRUNDIG_+_NOKIA|NOKIA]] || Nokia, z.B. D-Box
|-
| [[IRMP#IR60 (SDA2008)|IR60 (SDA2008)]] || Diverse europäische Hersteller
|-
| [[IRMP#JVC|JVC]] || JVC
|-
| [[IRMP#KASEIKYO|KASEIKYO]] || Panasonic, Technics, Denon und andere japanische Hersteller, welche Mitglied der "Japan's Association for Electric Home Application" sind.
|-
| [[IRMP#KATHREIN|KATHREIN]] || KATHREIN
|-
| [[IRMP#LEGO|LEGO]] || Lego
|-
| [[IRMP#LGAIR|LGAIR]] || LG Air Conditioner
|-
| [[IRMP#MITSU_HEAVY|MITSU_HEAVY]] || Mitsubishi Air Conditioner
|-
| [[IRMP#MATSUSHITA|MATSUSHITA]] || Matsushita
|-
| [[IRMP#NEC16|NEC16]] || JVC, Daewoo
|-
| [[IRMP#NEC42|NEC42]] || JVC
|-
| [[IRMP#MERLIN|MERLIN]] || MERLIN Fernbedienung (Pollin Bestellnummer: 620 185)
|-
| [[IRMP#NEC_+_extended_NEC|NEC]] || NEC, Yamaha, Canon, Tevion, Harman/Kardon, Hitachi, JVC, Pioneer, Toshiba, Xoro, Orion, NoName und viele weitere japanische Hersteller.
|-
| [[IRMP#NETBOX|NETBOX]] || Netbox
|-
| [[IRMP#NIKON|NIKON]] || NIKON
|-
| [[IRMP#NUBERT|NUBERT]] || Nubert, z.B. Subwoofer System
|-
| [[IRMP#ORTEK|ORTEK]] || Ortek, Hama
|-
| [[IRMP#PANASONIC|PANASONIC]] || PANASONIC Beamer
|-
| [[IRMP#PENTAX|PENTAX]] || PENTAX
|-
| [[IRMP#RC5_+_RC5X|RC5]] || Philips und andere europäische Hersteller
|-
| [[IRMP#RC6_+_RC6A|RC6A]] || Philips, Kathrein und andere Hersteller, z.B. XBOX
|-
| [[IRMP#RC6_+_RC6A|RC6]] || Philips und andere europäische Hersteller
|-
| [[IRMP#RCCAR|RCCAR]] || RC Car: IR Fernbedienung für Modellfahrzeuge
|-
| [[IRMP#RCII|RCII]] || T+A ('''NEU!''')
|-
| [[IRMP#RECS80|RECS80]] || Philips, Nokia, Thomson, Nordmende, Telefunken, Saba
|-
| [[IRMP#RECS80EXT|RECS80EXT]] || Philips, Technisat, Thomson, Nordmende, Telefunken, Saba
|-
| [[IRMP#RCMM|RCMM]] || Fujitsu-Siemens z.B. Activy keyboard
|-
| [[IRMP#ROOMBA|ROOMBA]] || iRobot Roomba Staubsauger
|-
| [[IRMP#S100|S100]] || Ähnlich zu RC5, aber 14 statt 13 Bits und 56kHz Modulation. Hersteller unbekannt.
|-
| [[IRMP#SAMSUNG32|SAMSUNG32]] || Samsung
|-
| [[IRMP#SAMSUNG48|SAMSUNG48]] || Div. Klimaanlagen Hersteller
|-
| [[IRMP#SAMSUNG|SAMSUNG]] || Samsung
|-
| [[IRMP#SIEMENS_+_RUWIDO|RUWIDO]] || RUWIDO (z.B. T-Home-Mediareceiver, MERLIN-Tastatur (Pollin))
|-
| [[IRMP#SIEMENS_+_RUWIDO|SIEMENS]] || Siemens, z.B. Gigaset M740AV
|-
| [[IRMP#SIRCS|SIRCS]] || Sony
|-
| [[IRMP#SPEAKER|SPEAKER]] || Lautsprecher Systeme wie z.B. X-Tensions
|-
| [[IRMP#TECHNICS|TECHNICS]] || Technics
|-
| [[IRMP#TELEFUNKEN|TELEFUNKEN]] || Telefunken
|-
| [[IRMP#THOMSON|THOMSON]] || Thomson
|-
| [[IRMP#VINCENT|VINCENT]] || Vincent
|}

'''NEU:'''

'''Ab Version 3.2 kann IRMP auch RF-Funkprotokolle (433 MHz) dekodieren.'''

{| {{Tabelle}}
|+ '''Unterstützte RF-Protokolle'''
|- style="background-color:#eeeeee"
! style="width:15%" | Protokoll
! style="width:100em" | Hersteller
|-
| [[IRMP#RF_GEN24|RF_GEN24]] || Generisches 24 Bit Format, z.B. Pollin 550666 Funksteckdose
|-
| [[IRMP#RF_X10|RF_X10]] || X10 PC Funkfernbedienung (Medion), Pollin 721815
|}

Jedes dieser Protokolle ist einzeln aktivierbar. Wer möchte, kann alle Protokolle aktivieren. Wer nur ein Protokoll braucht, kann alle anderen deaktivieren. Es wird nur das vom Compiler übersetzt, was auch benötigt wird.

Zu beachten:

* Sollen Funk-Protokolle decodiert werden, sind sämtliche IR-Protokolle zu deaktivieren.
* Sollen IR-Protokolle decodiert werden, sind sämtliche RF-Protokolle (Funk) zu deaktivieren.

=== Entstehung ===

Der auf AVR- und PIC-µCs einsetzbare Source zu [[IRMP#top|IRMP]] entstand im Rahmen des [[Word Clock]] Projektes.

=== Thread im Forum ===

'''Anlass für einen eigenen [[IRMP#top|IRMP]]-Artikel ist folgender Thread in der Codesammlung: [http://www.mikrocontroller.net/topic/162119 Beitrag: IRMP - Infrared Multi Protocol Decoder]'''

== IR-Protokolle ==

[[Datei:nec-protocol.png|miniatur|NEC-Protokoll, Reichelt RGB-LED-Fernbedienung, T->A: 9,14ms, A->B: 4,42ms, B->C: 660us]]

Einige Hersteller verwenden ihr eigenes hausinterne Protokoll, dazu gehören u.a. Sony, Samsung und Matsushita. Philips hat [[IRMP#RC5 + RC5X|RC5]] entwickelt und natürlich auch selbst benutzt. [[IRMP#RC5 + RC5X|RC5]] galt damals in Europa als ''das'' Standard-IR-Protokoll, welches von vielen europäischen Herstellern übernommen wurde. Mittlerweile ist [[IRMP#RC5 + RC5X|RC5]] fast gar nicht mehr anzutreffen - man kann es eigentlich als "ausgestorben" abhaken. Der Nachfolger [[IRMP#RC6_+_RC6A|RC6]] wird zwar noch in einigen aktuellen europäischen Geräten eingesetzt, ist aber auch nur vereinzelt vorzufinden.

Auch die japanischen Hersteller haben versucht, einen eigenen Standard zu etablieren, nämlich das sog. [[IRMP#KASEIKYO|Kaseikyo]]- (oder auch "Japan-") Protokoll. Dieses ist mit einer Bitlänge von 48 sehr universell und allgemein verwendbar. Richtig durchgesetzt hat es sich aber bis heute nicht - auch wenn man es hier und da im heimischen Haushalt vorfindet.

Heutzutage wird (auch vornehmlich bei japanischen Geräten) das [[IRMP#NEC_+_extended_NEC|NEC]]-Protokoll verwendet - und zwar von den unterschiedlichsten (Marken- und auch Noname-)Herstellern. Ich schätze den "Marktanteil" auf ca. 80% beim [[IRMP#NEC_+_extended_NEC|NEC]]-Protokoll. Fast alle Fernbedienungen im alltäglichen Einsatz verwenden bei mir den [[IRMP#NEC_+_extended_NEC|NEC]]-IR-Code. Das fängt beim Fernseher an, geht über vom DVD-Player zur Notebook-Fernbedienung und reicht bis zur Noname-MultiMedia-Festplatte - um nur einige Beispiele zu nennen.

== Kodierungen ==

[[IRMP#top|IRMP]] unterstützt folgende IR-Codings:

* [[IRMP#Pulse Distance|Pulse Distance]], typ. Beispiel: [[IRMP#NEC_+_extended_NEC|NEC]]
* [[IRMP#Pulse Width|Pulse Width]], typ. Beispiel: [[IRMP#SIRCS|Sony SIRCS]]
* [[IRMP#Biphase|Biphase (Manchester)]], typ. Beispiel: Philips [[IRMP#RC5_+_RC5X|RC5]], [[IRMP#RC6_+_RC6A|RC6]]
* [[IRMP#Pulse Position|Pulse Position (NRZ)]], typ. Beispiel: [[IRMP#NETBOX|Netbox]]
* [[IRMP#Pulse Distance Width|Pulse Distance Width]], typ. Beispiel: [[IRMP#NUBERT|Nubert]]

Die Pulse werden dabei moduliert - üblicherweise mit 36kHz oder 38kHz - um Umwelteinflüsse wie Raum- oder Sonnenlicht ausfiltern zu können.

=== Pulse Distance ===

[[Datei:Pulse-Distance.png|miniatur|Pulse Distance Coding]]

Eine Pulse Distance Kodierung erkennt man an der folgenden Regel:

* es gibt nur '''eine Pulslänge''' und '''zwei verschiedene Pausenlängen.'''

=== Pulse Width ===

[[Datei:Pulse-Width.png|miniatur|Pulse Width Coding]]

Bei der Pulse Width Kodierung gilt die Regel:

* es gibt '''zwei verschiedene Pulslängen''' und nur '''eine Pausenlänge'''

=== Pulse Distance Width ===

[[Datei:Pulse-Distance-Width.png|miniatur|Pulse Distance Width Coding]]

Dies ist ein Mischmasch aus Pulse Distance und Pulse Width Coding.

Also:

* es gibt '''zwei verschiedene Pulslängen''' und '''zwei verschiedene Pausenlängen.'''

=== Biphase ===

[[Datei:Biphase-Coding.png|miniatur|Biphase Coding]]

Bei der Biphase Kodierung entscheidet die Reihenfolge von Puls und Pause über den Wert des Bits.

Damit erkennt man ein Biphase-Coding an folgendem Kriterium:

* es kommen genau '''eine''' Pausen- und eine Pulslänge, sowie jeweils die '''doppelten''' Puls-/Pausenlängen vor

Normalerweise sind die Längen für die Pulse und Pausen gleich, d.h. die Signalform ist symmetrisch. IRMP erkennt aber auch Protokolle, die mit unterschiedlichen Puls-/Pause-Längen arbeiten. Dies ist zum Beispiel bei dem [[IRMP#A1TVBOX|A1TVBOX]]-Protokoll der Fall.

=== Pulse Position ===

[[Datei:Pulse-Position.png|miniatur|Pulse Position Coding]]

Die Pulse Position Kodierung kennt man von den üblichen UARTs. Hier hat jedes Bit eine feste Länge. Je nach Wert (0 oder 1) ist es ein Puls oder eine Pause.

Typisches Kriterium für ein '''Pulse Position Protokoll''' ist:

* es kommen '''Vielfache''' einer Grund-Puls-/Pausenlänge vor

'''Eine tabellarische Aufstellung der verschiedenen IR-Protokolle findet man hier: [[IRMP#Die_IR-Protokolle_im_Detail|Die IR-Protokolle im Detail]].'''

Die dort angegebenen Timingwerte sind Idealwerte. Bei einigen Fernbedienungen in der Praxis weichen sie um bis zu 40% voneinander ab. Deshalb arbeitet [[IRMP#top|IRMP]] mit Minimum-/Maximumsgrenzen, um bzgl. des Zeitverhaltens tolerabel zu sein.

== Protokoll-Erkennung ==

Die meisten der von [[IRMP#top|IRMP]] decodierten Protokolle haben etwas gemeinsames: Sie weisen ein Start-Bit auf, welches vom Timing her ausgezeichnet, d.h. einmalig ist.

Anhand dieses Start-Bit-Timings werden meistens die verschiedenen Protokolle unterschieden. [[IRMP#top|IRMP]] misst also das Timing des Start-Bits und stellt dann "on-the-fly" seine Timingtabellen auf das erkannte Protokoll um, damit die nach dem Start-Bit gesandten Daten in einem Rutsch eingelesen werden können, ohne das komplette Telegramm (Frame) erst speichern zu müssen. [[IRMP#top|IRMP]] wartet also nicht darauf, dass ein kompletter Frame eingelesen wurde, sondern legt direkt nach der ersten Pulserkennung los.

Ist das gelesene Start-Bit nicht eindeutig, fährt [[IRMP#top|IRMP]] "mehrspurig", d.h. es werden zum Beispiel zwei mögliche Protokolle gleichzeitig verfolgt. Sobald aus Plausibilitätsgründen eines der beiden Protokolle nicht mehr möglich sein kann, wird komplett auf das andere Protokoll gewechselt.

Realisiert wird die Erkennung über eine [[Statemachine]], die [[AVR-GCC-Tutorial/Die_Timer_und_Zähler_des_AVR|timergesteuert]] über eine [[Interrupt|Interruptroutine]] in regelmäßigen Abständen (üblicherweise 15.000 mal in der Sekunde) aufgerufen wird. Die [[Statemachine]] kennt (unter anderem) folgende Zustände:

* Erkenne den ersten Puls des Start-Bits
* Erkenne die Pause des Start-Bits
* Erkenne den Puls des ersten Datenbits

Danach sind die Puls/Pause-Längen des Startbits bekannt. Nun werden alle vom Anwender aktivierten Protokolle nach diesen Längen durchsucht. Wurde ein Protokoll gefunden, werden die Timing-Tabellen dieses Protokolls geladen und im weiteren geprüft, ob die nachfolgenden Puls-/Pause-Zeiten innerhalb der geladenen Werte übereinstimmen.

Es geht also weiter in der [[Statemachine]] mit folgenden Zuständen

* Erkenne die Pausen der Datenbits
* Erkenne die Pulse der Datenbits
* Prüfe Timing. Wenn abweichend, schalte um auf ein anderes noch in Frage kommendes IR-Protokoll, ansonsten schalte [[Statemachine]] komplett zurück
* Erkenne das Stop-Bit, falls das Protokoll eines vorsieht
* Prüfe Daten auf Plausibilität, wie CRC oder andere redundante Datenbits
* Wandle die Daten in Geräte-Adresse und Kommando
* Erkenne Wiederholungen durch längere Tastendrücke, setze entsprechendes Flag

Tatsächlich ist die [[Statemachine]] noch etwas komplizierter, da manche Protokolle gar kein Start-Bit (z.B. [[IRMP#DENON|Denon]]) bzw. mehrere Start-Bits (z.B. 4 bei [[IRMP#B.26O|B&O]]) haben bzw. mitten im Frame ein weiteres Synchronisierungs-Bit (z.B. [[IRMP#SAMSUNG|Samsung]]) vorsehen. Diese besonderen Bedingungen werden durch protokollspezifische "Spezialbehandlungen" im Code abgefangen.

Das Umschalten auf ein anderes Protokoll kann mehrfach während des Empfangs des Frames geschehen, z.B. von [[IRMP#NEC42|NEC42]] (42 Bit) auf [[IRMP#NEC16|NEC16]] (8 Bit + Sync-Bit + 8 Bit), wenn vorzeitig ein zusätzliches Synchronisierungsbit erkannt wurde, oder von [[IRMP#NEC + extended NEC|NEC]]/[[IRMP#NEC42|NEC42]] (32/42 Bit) auf [[IRMP#JVC|JVC]] (16 Bit), wenn das Stop-Bit vorzeitig auftrat. Schwierig wird es dann, wenn zwei mögliche Protokolle nach Erkennung des Start-Bits unterschiedliche Kodierungen verwenden, z.B. wenn das eine Protokoll ein [[IRMP#Pulse Distance|Pulse Distance Coding]] und das andere ein [[IRMP#Biphase|Biphase Coding (Manchester)]] benutzt. Hier speichert [[IRMP#top|IRMP]] die jeweils völlig verschieden ermittelten Bits für beide Codierungen, um dann später die einen oder anderen
Werte wieder zu verwerfen.

Desweiteren senden einige Fernbedienungen bei bestimmten Protokollen aus Gründen der Redundanz (Fehlererkennung) oder wegen längeren Tastendrucks Wiederholungsframes. Diese werden von IRMP unterschieden: Die für die Fehlererkennung zuständigen Frames werden von IRMP geprüft, aber nicht an die Anwendung zurückgegeben, die anderen werden als langer Tastendruck erkannt und entsprechend von IRMP gekennzeichnet.

== Download ==

Version 3.2.6, Stand vom 27.01.2021

Download Stable Version: [http://www.mikrocontroller.net/wikifiles/7/79/Irmp.zip Irmp.zip]

Aktuelle Entwicklungsversion von [[IRMP#top|IRMP]] & [[IRSND#top|IRSND]]:

* SVN-Link: [svn://mikrocontroller.net/irmp/ SVN]
* SVN-Browser: [http://www.mikrocontroller.net/svnbrowser/irmp/ IRMP im SVN]
* Download Tarball: [http://www.mikrocontroller.net/svnbrowser/irmp/?view=tar Tarball]

Download als Arduino Library: [https://github.com/ukw100/IRMP GitHub] oder in der Arduino IDE "''Tools / Manage Libraries...''" benutzen und nach "''IRMP''" suchen. Dies ist eine speziell an Arduino angepasste Version. Diese Variante hinkt manchmal der aktuellen Version etwas hinterher.

'''Die Software-Änderungen kann man sich hier anschauen: [http://www.mikrocontroller.net/articles/IRMP#Software-Historie_IRMP Software-Historie IRMP]'''

== Lizenz ==

IRMP ist Open Source Software und wird unter der [https://www.gnu.org/licenses/old-licenses/gpl-2.0.html GPL v2] (oder jeder höheren Version) freigegeben.

== Source-Code ==

Der Source-Code lässt sich einfach für AVR-µCs übersetzen, indem man unter Windows die Projekt-Datei irmp.aps in das AVR Studio 4 lädt.

Für andere Entwicklungsumgebungen ist leicht ein Projekt bzw. Makefile angelegt. Zum Source gehören:

* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp.c?view=markup irmp.c] - Der eigentliche IR-Decoder
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmpprotocols.h?view=markup irmpprotocols.h] - Sämtliche Definitionen zu den IR-Protokollen
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmpsystem.h?view=markup irmpsystem.h] - Vom Zielsystem abhängige Definitionen für AVR/PIC/STM32
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp.h?view=markup irmp.h] - Include-Datei für die Applikation
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] - Anzupassende Konfigurationsdatei

Beispiel Anwendungen (main-Funktionen und nötige Timer-Initialisierungen):

* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-avr.c?view=markup irmp-main-avr.c] - AVR
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-avr-uart.c?view=markup irmp-main-avr-uart.c] - AVR mit UART-Ausgabe
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-pic-xc8.c?view=markup irmp-main-pic-xc8.c] - PIC18F4520
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-pic-12F1840.c?view=markup irmp-main-pic-12F1840.c] - PIC12F1840
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-stm32.c?view=markup irmp-main-stm32.c] - STM32
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-stellaris-arm.c?view=markup irmp-main-stellaris-arm.c] - TI Stellaris LM4F120 Launchpad
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-esp8266.c?view=markup irmp-main-esp8266.c] - ESP8266
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-mbed.cpp?view=markup irmp-main-mbed.cpp] - MBED
* [http://www.mikrocontroller.net/svnbrowser/irmp/examples/Arduino/Arduino.ino?view=markup examples/Arduino/Arduino.ino] - Teensy 3.x
* [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-chibios.c?view=markup irmp-main-chibios.c] - ChibiOS

{{Warnung|
;WICHTIG: Im Applikations-Source sollte nur irmp.h per include eingefügt werden, also lediglich:
<syntaxhighlight lang="c">
#include "irmp.h"
</syntaxhighlight>

Alle anderen Include-Dateien werden automatisch über irmp.h "eingefügt". Siehe dazu auch die Beispieldatei irmp-main-avr.c.

Desweiteren muss die Preprocessor-Konstante '''F_CPU im Projekt bzw. Makefile''' gesetzt werden. Diese sollte mindestens den Wert 8000000UL haben, der Prozessor sollte also zumindest mit 8 MHz laufen.
}}

Auch auf PIC-Prozessoren ist [[IRMP#top|IRMP]] lauffähig. Für den PIC-CCS-Compiler sind entsprechende Preprocessor-Konstanten bereits gesetzt, so dass man [http://www.mikrocontroller.net/svnbrowser/irmp/irmp.c?view=markup irmp.c] direkt in der CCS-Entwicklungsumgebung verwenden kann. Lediglich eine kleine Interrupt-Routine wie

<syntaxhighlight lang="c">
void TIMER2_isr(void)
{
irmp_ISR ();
}
</syntaxhighlight>

ist hinzuzufügen, wobei man den Interrupt auf 66µs (also 15kHz) stellt.

Für AVR-Prozessoren ist ein Beispiel für die Anwendung von [[IRMP#top|IRMP]] in [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-avr.c?view=markup irmp-main-avr.c] zu finden - im wesentlichen geht es da um die [[AVR-GCC-Tutorial/Die_Timer_und_Zähler_des_AVR|Timer]]-Initialisierung und den Abruf der empfangenen IR-Telegramme. Das empfangene Protokoll, die Geräte-Adresse und der Kommando-Code wird dann in der AVR-Version auf dem HW-UART ausgegeben.

Für das Stellaris LM4F120 Launchpad von TI (ARM Cortex M4) ist eine entsprechende Timer-Initialisierungsfunktion in [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-stellaris-arm.c?view=markup irmp-main-stellaris-arm.c] bereits integriert.

Ebenso kann [[IRMP#top|IRMP]] auf STM32-Mikroprozessoren eingesetzt werden.

=== avr-gcc-Optimierungen ===

Ab Version avr-gcc 4.7.x kann die [https://gcc.gnu.org/onlinedocs/gccint/LTO.html#LTO LTO-Option] genutzt werden, um den Aufruf der externen Funktion irmp_ISR() aus der eigentlichen ISR effizienter zu machen. Das verbessert das Zeitverhalten der ISR etwas.

Zu den sonst schon üblichen Compiler- und Linker-Optionen kommen noch folgende dazu:

* Zusätzliche Compiler-Option: -flto
* Zusätzliche Linker-Optionen: -flto -Os

Vergisst man (unter Windows?) die zusätzliche Linker-Option -Os, wird das Binary allerdings wesentlich größer, da dann nicht mehr optimiert wird. Auch muss -flto an den Linker übergeben werden, weil sonst die LTO-Optimierung nicht mehr greift.

=== Konfiguration ===

Die Konfiguration von [[IRMP#top|IRMP]] wird über Parameter in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] vorgenommen, nämlich:

* [[IRMP#F_INTERRUPTS|Anzahl Interrupts pro Sekunde]]
* [[IRMP#IRMP_SUPPORT_xxx_PROTOCOL|Unterstützte IR-Protokolle]]
* [[IRMP#IRMP_PORT_LETTER + IRMP_BIT_NUMBER|Hardware-Pin zum IR-Empfänger]]
* [[IRMP#IRMP_LOGGING|IR-Logging]]

=== Einstellungen in irmpconfig.h ===

[[IRMP#top|IRMP]] decodiert sämtliche oben aufgelisteten Protokolle in einer ISR. Dafür sind einige Angaben nötig. Diese werden in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] eingestellt.

==== F_INTERRUPTS ====

Anzahl der Interrupts pro Sekunde. Der Wert kann zwischen 10000 und 20000 eingestellt werden. Je höher der Wert, desto besser die Auflösung und damit die Erkennung. Allerdings erkauft man sich diesen Vorteil mit erhöhter CPU-Last. Der Wert 15000 ist meist ein guter Kompromiss.

Standardwert:
<syntaxhighlight lang="c">
#define F_INTERRUPTS 15000 // interrupts per second
</syntaxhighlight>

Auf AVR-Prozessoren wird in der Beispielroutine in [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-avr.c?view=markup irmp-main-avr.c] der Timer1 mit 16-Bit-Genauigkeit verwendet. Sollte der Timer1 aus irgendwelchen Gründen nicht verfügbar sein, kann man alternativ auch den Timer2 mit 8-Bit-Genauigkeit verwenden.

In diesem Fall wird dieser dann konfiguriert über:

Für ATmega8/ATmega16/ATmega32:
<syntaxhighlight lang="c">
OCR2 = (uint8_t) ((F_CPU / F_INTERRUPTS) / 8) - 1 + 0.5); // Compare Register OCR2
TCCR2 = (1 << WGM21) | (1 << CS21); // CTC Mode, prescaler = 8
TIMSK = 1 << OCIE2; // enable timer2 interrupt

ISR(TIMER2_COMP_vect)
{
(void) irmp_ISR();
}
</syntaxhighlight>

Für ATmega88/ATmega168/ATmega328:
<syntaxhighlight lang="c">
OCR2A = (uint8_t) ((F_CPU / F_INTERRUPTS) / 8) - 1 + 0.5); // Compare Register OCR2
TCCR2A = (1 << WGM21); // CTC Mode, prescaler = 8
TCCR2B = (1 << CS21); // CTC Mode, prescaler = 8
TIMSK2 = 1 << OCIE2A; // enable timer2 interrupt

ISR(TIMER2_COMPA_vect)
{
(void) irmp_ISR();
}
</syntaxhighlight>

Bei anderen AVR-µCs empfiehlt sich ein Blick ins Datenblatt.

Man sollte in diesem Fall nicht vergessen, auch die Interrupt-Routine an den Timer2 anzupassen:

==== IRMP_SUPPORT_xxx_PROTOCOL ====

Hier lässt sich einstellen, welche Protokolle von [[IRMP#top|IRMP]] unterstützt werden sollen. Die Standardprotokolle sind bereits aktiv. Möchte man weitere Protokolle einschalten bzw. einige aus Speicherplatzgründen deaktivieren, sind die entsprechenden Werte in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] anzupassen.

<syntaxhighlight lang="c">
// typical protocols, disable here! Enable Remarks F_INTERRUPTS Program Space
#define IRMP_SUPPORT_SIRCS_PROTOCOL 1 // Sony SIRCS >= 10000 ~150 bytes
#define IRMP_SUPPORT_NEC_PROTOCOL 1 // NEC + APPLE >= 10000 ~300 bytes
#define IRMP_SUPPORT_SAMSUNG_PROTOCOL 1 // Samsung + Samsung32 >= 10000 ~300 bytes
#define IRMP_SUPPORT_MATSUSHITA_PROTOCOL 1 // Matsushita >= 10000 ~50 bytes
#define IRMP_SUPPORT_KASEIKYO_PROTOCOL 1 // Kaseikyo >= 10000 ~250 bytes

// more protocols, enable here! Enable Remarks F_INTERRUPTS Program Space
#define IRMP_SUPPORT_DENON_PROTOCOL 0 // DENON, Sharp >= 10000 ~250 bytes
#define IRMP_SUPPORT_RC5_PROTOCOL 0 // RC5 >= 10000 ~250 bytes
#define IRMP_SUPPORT_RC6_PROTOCOL 0 // RC6 & RC6A >= 10000 ~250 bytes
#define IRMP_SUPPORT_JVC_PROTOCOL 0 // JVC >= 10000 ~150 bytes
#define IRMP_SUPPORT_NEC16_PROTOCOL 0 // NEC16 >= 10000 ~100 bytes
#define IRMP_SUPPORT_NEC42_PROTOCOL 0 // NEC42 >= 10000 ~300 bytes
#define IRMP_SUPPORT_IR60_PROTOCOL 0 // IR60 (SDA2008) >= 10000 ~300 bytes
#define IRMP_SUPPORT_GRUNDIG_PROTOCOL 0 // Grundig >= 10000 ~300 bytes
#define IRMP_SUPPORT_SIEMENS_PROTOCOL 0 // Siemens Gigaset >= 15000 ~550 bytes
#define IRMP_SUPPORT_NOKIA_PROTOCOL 0 // Nokia >= 10000 ~300 bytes

// exotic protocols, enable here! Enable Remarks F_INTERRUPTS Program Space
#define IRMP_SUPPORT_BOSE_PROTOCOL 0 // BOSE >= 10000 ~150 bytes
#define IRMP_SUPPORT_KATHREIN_PROTOCOL 0 // Kathrein >= 10000 ~200 bytes
#define IRMP_SUPPORT_NUBERT_PROTOCOL 0 // NUBERT >= 10000 ~50 bytes
#define IRMP_SUPPORT_BANG_OLUFSEN_PROTOCOL 0 // Bang & Olufsen >= 10000 ~200 bytes
#define IRMP_SUPPORT_RECS80_PROTOCOL 0 // RECS80 (SAA3004) >= 15000 ~50 bytes
#define IRMP_SUPPORT_RECS80EXT_PROTOCOL 0 // RECS80EXT (SAA3008) >= 15000 ~50 bytes
#define IRMP_SUPPORT_THOMSON_PROTOCOL 0 // Thomson >= 10000 ~250 bytes
#define IRMP_SUPPORT_NIKON_PROTOCOL 0 // NIKON camera >= 10000 ~250 bytes
#define IRMP_SUPPORT_NETBOX_PROTOCOL 0 // Netbox keyboard >= 10000 ~400 bytes (PROTOTYPE!)
#define IRMP_SUPPORT_ORTEK_PROTOCOL 0 // ORTEK (Hama) >= 10000 ~150 bytes
#define IRMP_SUPPORT_TELEFUNKEN_PROTOCOL 0 // Telefunken 1560 >= 10000 ~150 bytes
#define IRMP_SUPPORT_FDC_PROTOCOL 0 // FDC3402 keyboard >= 10000 (better 15000) ~150 bytes (~400 in combination with RC5)
#define IRMP_SUPPORT_RCCAR_PROTOCOL 0 // RC Car >= 10000 (better 15000) ~150 bytes (~500 in combination with RC5)
#define IRMP_SUPPORT_ROOMBA_PROTOCOL 0 // iRobot Roomba >= 10000 ~150 bytes
#define IRMP_SUPPORT_RUWIDO_PROTOCOL 0 // RUWIDO, T-Home >= 15000 ~550 bytes
#define IRMP_SUPPORT_A1TVBOX_PROTOCOL 0 // A1 TV BOX >= 15000 (better 20000) ~300 bytes
#define IRMP_SUPPORT_LEGO_PROTOCOL 0 // LEGO Power RC >= 20000 ~150 bytes
#define IRMP_SUPPORT_RCMM_PROTOCOL 0 // RCMM 12,24, or 32 >= 20000 ~150 bytes
</syntaxhighlight>

Jedes von [[IRMP#top|IRMP]] unterstützte IR-Protokoll "verbrät" ungefähr den oben angegebenen Speicher an Code. Hier kann man Optimierungen vornehmen: Zum Beispiel ist die Modulationsfrequenz von 455kHz beim [[IRMP#B&O|B&O]]-Protokoll weitab von den Frequenzen, die von den anderen Protokollen verwendet werden. Hier braucht man evtl. andere IR-Empfänger, anderenfalls kann man diese Protokolle einfach deaktiveren. Zum Beispiel kann man mit einem TSOP1738 kein [[IRMP#B&O|B&O]]-Protokoll (455kHz) mehr empfangen.

Ausserdem werden die Protokolle [[IRMP#SIEMENS_+_RUWIDO|SIEMENS]]/[[IRMP#FDC|FDC]]/[[IRMP#RCCAR|RCCAR]] erst ab einer Scan-Frequenz von ca. 15kHz zuverlässig erkannt. Bei [[IRMP#LEGO|LEGO]] sind es sogar 20kHz. Wenn man also diese Protokolle nutzen will, muss man [[IRMP#F_INTERRUPTS|F_INTERRUPTS]] entsprechend anpassen, sonst erscheint beim Übersetzen eine entsprechende Warnung und die entsprechenden Protokolle werden dann automatisch abgeschaltet.

==== IRMP_PORT_LETTER + IRMP_BIT_NUMBER ====

Über diese Konstanten wird der Pin am µC beschrieben, an welchem der IR-Empfänger angeschlossen ist.

Standardwert ist PORT B6:
<syntaxhighlight lang="c">
/*----------------------------------------------------------------------------------------------------------------
* Change hardware pin here for ATMEL AVR
*----------------------------------------------------------------------------------------------------------------
*/
#if defined (ATMEL_AVR) // use PB6 as IR input on AVR
# define IRMP_PORT_LETTER B
# define IRMP_BIT_NUMBER 6
</syntaxhighlight>

Diese beiden Werte sind an den tatsächlichen Hardware-Pin des µCs anzupassen.

Dies gilt ebenso für die STM32-µCs:

<syntaxhighlight lang="c">
/*----------------------------------------------------------------------------------------------------------------
* Change hardware pin here for ARM STM32
*----------------------------------------------------------------------------------------------------------------
*/
#elif defined (ARM_STM32) // use C13 as IR input on STM32
# define IRMP_PORT_LETTER C
# define IRMP_BIT_NUMBER 13
</syntaxhighlight>

Wird die STM32-HAL Library verwendet, definiert man die beiden Konstanten IRSND_Transmit_GPIO_Port und IRSND_Transmit_Pin in STM32Cube (Main.h). In diesem Fall ist hier nichts weiter anzupassen:
<syntaxhighlight lang="c">
/*----------------------------------------------------------------------------------------------------------------
* ARM STM32 with HAL section - don't change here, define IRSND_Transmit_GPIO_Port & IRSND_Transmit_Pin in STM32Cube (Main.h)
*----------------------------------------------------------------------------------------------------------------
*/
#elif defined (ARM_STM32_HAL) // IRSND_Transmit_GPIO_Port & IRSND_Transmit_Pin must be defined in STM32Cube
# define IRSND_PORT_LETTER IRSND_Transmit_GPIO_Port//Port of Transmit PWM Pin e.g.
# define IRSND_BIT_NUMBER IRSND_Transmit_Pin //Pim of Transmit PWM Pin e.g.
# define IRSND_TIMER_HANDLER htim2 //Handler of Timer e.g. htim (see tim.h)
# define IRSND_TIMER_CHANNEL_NUMBER TIM_CHANNEL_2 //Channel of the used Timer PWM Pin e.g. TIM_CHANNEL_2
# define IRSND_TIMER_SPEED_APBX 64000000 //Speed of the corresponding APBx. (see STM32CubeMX: Clock Configuration)
</syntaxhighlight>

Hier der entsprechende Abschnitt für STM8-µCs:

<syntaxhighlight lang="c">
/*----------------------------------------------------------------------------------------------------------------
* Change hardware pin here for STM8
*----------------------------------------------------------------------------------------------------------------
*/
#elif defined (SDCC_STM8) // use PA1 as IR input on STM8
# define IRMP_PORT_LETTER A
# define IRMP_BIT_NUMBER 1
</syntaxhighlight>

Bei den PIC-Prozessoren gibt es lediglich die anzupassende Konstante '''IRMP_PIN''' - je nach Compiler:

<syntaxhighlight lang="c">
/*----------------------------------------------------------------------------------------------------------------
* Change hardware pin here for PIC C18 compiler
*----------------------------------------------------------------------------------------------------------------
*/
#elif defined (PIC_C18) // use RB4 as IR input on PIC
# define IRMP_PIN PORTBbits.RB4

/*----------------------------------------------------------------------------------------------------------------
* Change hardware pin here for PIC CCS compiler
*----------------------------------------------------------------------------------------------------------------
*/
#elif defined (PIC_CCS) // use PB4 as IR input on PIC
# define IRMP_PIN PIN_B4
</syntaxhighlight>

Bei ChibiOS HAL definiert man in der Board-Config (board.chcfg) von ChibiOS einen Pin mit dem Namen '''IR_IN''' und generiert die Boarddatei neu. Wenn man einen anderen Namen für den Pin verwenden möchte, kann man auch die Konstante '''IRMP_PIN'''
in der irmpconfig.h anpassen. Vor den Namen des Pins aus der Board-Config dann "LINE_" voranstellen, da in IRMP die
"Line"-Variante der PAL-Schnittstelle verwendet wird:

<syntaxhighlight lang="c">
/*----------------------------------------------------------------------------------------------------------------
* Change hardware pin here for ChibiOS HAL
*----------------------------------------------------------------------------------------------------------------
*/
#elif defined(_CHIBIOS_HAL_)
# define IRMP_PIN LINE_IR_IN // use pin names as defined in the board config file, prefixed with "LINE_"
</syntaxhighlight>

==== IRMP_HIGH_ACTIVE ====

Standardwert:
<syntaxhighlight lang="c">
# define IRMP_HIGH_ACTIVE 0 // set to 1 if you use a RF receiver!
</syntaxhighlight>

Setzt man einen Funkempfänger statt einem IR-Sensor ein, um Funkprotokolle zu decodieren, so arbeiten diese in der Regel mit aktivem High-Pegel. Deshalb sollte man diesen Wert dann auf 1 setzen.

'''NEU:'''

==== IRMP_ENABLE_RELEASE_DETECTION ====

Standardwert:
<syntaxhighlight lang="c">
# define IRMP_ENABLE_RELEASE_DETECTION 0 // enable detection of key releases
</syntaxhighlight>

Wird dieser Wert auf 1 gesetzt, kann das Loslassen einer Fernbedienungstaste detektiert werden. Die Funktion irmp_get_data() setzt dann im Struct-Member irmp_data.flags das Bit IRMP_FLAG_RELEASE, sobald das Senden eines Codes aufgehört hat. Ein praktisches Beispiel dafür findet man im Kapitel '''[[IRMP#.22Entprellen.22_von_Tasten|Entprellen von Tasten]]'''.

==== IRMP_USE_CALLBACK ====

Standardwert:
<syntaxhighlight lang="c">
#define IRMP_USE_CALLBACK 0 // flag: 0 = don't use callbacks, 1 = use callbacks, default is 0
</syntaxhighlight>

Wenn man Callbacks einschaltet, wird bei jeder Pegeländerung des Eingangs eine Callback-Funktion aufgerufen. Dies kann zum Beispiel dafür verwendet werden, das eingehende IR-Signal sichtbar zu machen, also als Signal an einem weiteren Pin auszugeben.

Hier ein Beispiel:

<syntaxhighlight lang="c">
#define LED_PORT PORTD // LED at PD6
#define LED_DDR DDRD
#define LED_PIN 6

/*------------------------------------------------------------------------------------------------------------
* Called (back) from IRMP module
* This example switches a LED (which is connected to Vcc)
*-------------------------------------------------------------------------------------------------------------
*/
void
led_callback (uint_fast8_t on)
{
if (on)
{
LED_PORT &= ~(1 << LED_PIN);
}
else
{
LED_PORT |= (1 << LED_PIN);
}
}

int
main ()
{
...
irmp_init ();

LED_DDR |= (1 << LED_PIN); // LED pin to output
LED_PORT |= (1 << LED_PIN); // switch LED off (active low)
irmp_set_callback_ptr (led_callback);

sei ();
...
}
</syntaxhighlight>

==== IRMP_USE_IDLE_CALL ====

Normalerweise wird die Funktion irmp_ISR() ständig mit der Frequenz F_INTERRUPTS (10-20kHz) aufgerufen. Der Controller
kann daher kaum in einen energiesparenden Sleep-Modus wechseln, bzw. muss ständig aus diesem wieder aufwachen. Kommt
es auf den Stromverbrauch an, wie z.B. bei Batteriebetrieb, ist diese Vorgehensweise nicht optimal.

Wenn man '''IRMP_USE_IDLE_CALL''' aktiviert, erkennt IRMP wenn kein IR-Empfang im Gange ist und ruft dann die Funktion
'''irmp_idle()''' auf. Diese ist controllerspezifisch und muss vom Nutzer bereitgestellt und hinzugelinkt werden. Dort kann dann in den Empfangspausen der Controller schlafen gelegt und so der Energieverbrauch reduziert werden.

Empfohlen wird in der irmp_idle() den Timer-Interrupt zu deaktivieren und statt dessen einen Pinchange-Interrupt zu aktivieren. Danach kann der Controller schlafen geschickt werden. Wird eine fallende Flanke auf dem IR-Eingang erkannt, wird der Pinchange-Interrupt deaktiviert, der Timer wieder aktiviert und sofort irmp_ISR() aufgerufen. Ein Beispiel für die Verwendung von irmp_idle() findet sich in [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-chibios.c?view=markup irmp-main-chibios.c].

IRMP rein anhand von Pinchange-Interrupts und ohne Timer-Interrupts zu betreiben ist nicht vorgesehen.

==== IRMP_USE_EVENT ====

Wenn man IRMP zusammen mit ChibiOS/RT oder ChibiOS/NIL verwendet, kann man deren Event-System verwenden um einen
Thread aufzuwecken sobald neue IR-Daten empfangen und decodiert wurden.

Dazu setzt man in der irmpconfig.h die Konstante '''IRMP_USE_EVENT''' auf 1. '''IRMP_EVENT_BIT''' definiert den
Bitwert in der Event-Bitmaske, der den IRMP-Event symbolisieren soll. Mit '''IRMP_EVENT_THREAD_PTR''' wird der
Variablenname des Threadpointers festgelegt, an den der Event gesendet wird.

In der irmpconfig.h sieht das in der Praxis so aus:
<syntaxhighlight lang="c">
/*------------------------------------------------------------------------------------------------------------
* Use ChibiOS Events to signal that valid IR data was received
*------------------------------------------------------------------------------------------------------------
*/
#if defined(_CHIBIOS_RT_) || defined(_CHIBIOS_NIL_)

# ifndef IRMP_USE_EVENT
# define IRMP_USE_EVENT 1 // 1: use event. 0: do not. default is 0
# endif

# if IRMP_USE_EVENT == 1 && !defined(IRMP_EVENT_BIT)
# define IRMP_EVENT_BIT 1 // event flag or bit to send
# endif
# if IRMP_USE_EVENT == 1 && !defined(IRMP_EVENT_THREAD_PTR)
# define IRMP_EVENT_THREAD_PTR ir_receive_thread_p // pointer to the thread to send the event to
extern thread_t *IRMP_EVENT_THREAD_PTR; // the pointer must be defined and initialized elsewhere
# endif

#endif // _CHIBIOS_RT_ || _CHIBIOS_NIL_
</syntaxhighlight>

In seinem ChibiOS-Projekt verwendet man das dann so:
<syntaxhighlight lang="c">
thread_t *ir_receive_thread_p = NULL;

static THD_FUNCTION(IRThread, arg)
{
ir_receive_thread_p = chThdGetSelfX();
[...]
while (true)
{
// wait for event sent from irmp_ISR
chEvtWaitAnyTimeout(ALL_EVENTS,TIME_INFINITE);

if (irmp_get_data (&irmp_data))
// Daten aus irmp_data verwenden
</syntaxhighlight>

==== IRMP_LOGGING ====

Mit IRMP_LOGGING kann das Protokollieren von eingehenden IR-Frames eingeschaltet werden.

Standardwert:
<syntaxhighlight lang="c">
#define IRMP_LOGGING 0 // 1: log IR signal (scan), 0: do not. default is 0
</syntaxhighlight>

Weitere Erläuterungen siehe [[IRMP#Scannen_von_unbekannten_IR-Protokollen|Scannen von unbekannten IR-Protokollen]].

'''Beachte: In der Regel braucht man IRMP_LOGGING nur dafür, um Samples aus den empfangenen IR-Frames zu erstellen, die weiter analysiert werden sollen. Daher sollte man sonst den Wert von IRMP_LOGGING immer auf 0 lassen.'''

=== Anwendung von IRMP ===

Die von [[IRMP#top|IRMP]] unterstützten Protokolle weisen Bitlängen - teilweise variabel, teilweise fest - von 2 bis 48 Bit auf. Diese werden über Preprocessor-Defines beschrieben.

[[IRMP#top|IRMP]] trennt diese IR-Telegramme prinzipiell in 3 Bereiche:

1. ID für verwendetes Protokoll
2. Adresse bzw. Herstellercode
3. Kommando

Mittels der Funktion

irmp_get_data (IRMP_DATA * irmp_data_p)

kann man ein decodiertes Telegramm abrufen. Der Return-Wert ist 1, wenn ein Telegramm eingelesen wurde, sonst 0. Im ersten Fall werden die Struct-Members

<syntaxhighlight lang="c">
irmp_data_p->protocol (8 Bit)
irmp_data_p->address (16 Bit)
irmp_data_p->command (16 Bit)
irmp_data_p->flags (8 Bit)
</syntaxhighlight>

gefüllt.

Das heisst: am Ende bekommt man dann über irmp_get_data() einfach drei
Werte (Protokoll, Adresse und Kommando-Code), die man über ein if oder switch checken kann, z. B. hier eine Routine, welche die Tasten 1-9 auf einer Fernbedienung auswertet:

<syntaxhighlight lang="c">
IRMP_DATA irmp_data;

if (irmp_get_data (&irmp_data))
{
if (irmp_data.protocol == IRMP_NEC_PROTOCOL && // NEC-Protokoll
irmp_data.address == 0x1234) // Adresse 0x1234
{
switch (irmp_data.command)
{
case 0x0001: key1_pressed(); break; // Taste 1
case 0x0002: key2_pressed(); break; // Taste 2
...
case 0x0009: key9_pressed(); break; // Taste 9
}
}
}
</syntaxhighlight>

Hier die möglichen Werte für irmp_data.protocol, siehe auch [http://www.mikrocontroller.net/svnbrowser/irmp/irmpprotocols.h?view=markup irmpprotocols.h]:

<syntaxhighlight lang="c">
#define IRMP_SIRCS_PROTOCOL 1 // Sony
#define IRMP_NEC_PROTOCOL 2 // NEC, Pioneer, JVC, Toshiba, NoName etc.
#define IRMP_SAMSUNG_PROTOCOL 3 // Samsung
#define IRMP_MATSUSHITA_PROTOCOL 4 // Matsushita
#define IRMP_KASEIKYO_PROTOCOL 5 // Kaseikyo (Panasonic etc)
#define IRMP_RECS80_PROTOCOL 6 // Philips, Thomson, Nordmende, Telefunken, Saba
#define IRMP_RC5_PROTOCOL 7 // Philips etc
#define IRMP_DENON_PROTOCOL 8 // Denon, Sharp
#define IRMP_RC6_PROTOCOL 9 // Philips etc
#define IRMP_SAMSUNG32_PROTOCOL 10 // Samsung32: no sync pulse at bit 16, length 32 instead of 37
#define IRMP_APPLE_PROTOCOL 11 // Apple, very similar to NEC
#define IRMP_RECS80EXT_PROTOCOL 12 // Philips, Technisat, Thomson, Nordmende, Telefunken, Saba
#define IRMP_NUBERT_PROTOCOL 13 // Nubert
#define IRMP_BANG_OLUFSEN_PROTOCOL 14 // Bang & Olufsen
#define IRMP_GRUNDIG_PROTOCOL 15 // Grundig
#define IRMP_NOKIA_PROTOCOL 16 // Nokia
#define IRMP_SIEMENS_PROTOCOL 17 // Siemens, e.g. Gigaset
#define IRMP_FDC_PROTOCOL 18 // FDC keyboard
#define IRMP_RCCAR_PROTOCOL 19 // RC Car
#define IRMP_JVC_PROTOCOL 20 // JVC (NEC with 16 bits)
#define IRMP_RC6A_PROTOCOL 21 // RC6A, e.g. Kathrein, XBOX
#define IRMP_NIKON_PROTOCOL 22 // Nikon
#define IRMP_RUWIDO_PROTOCOL 23 // Ruwido, e.g. T-Home Mediareceiver
#define IRMP_IR60_PROTOCOL 24 // IR60 (SDA2008)
#define IRMP_KATHREIN_PROTOCOL 25 // Kathrein
#define IRMP_NETBOX_PROTOCOL 26 // Netbox keyboard (bitserial)
#define IRMP_NEC16_PROTOCOL 27 // NEC with 16 bits (incl. sync)
#define IRMP_NEC42_PROTOCOL 28 // NEC with 42 bits
#define IRMP_LEGO_PROTOCOL 29 // LEGO Power Functions RC
#define IRMP_THOMSON_PROTOCOL 30 // Thomson
#define IRMP_BOSE_PROTOCOL 31 // BOSE
#define IRMP_A1TVBOX_PROTOCOL 32 // A1 TV Box
#define IRMP_ORTEK_PROTOCOL 33 // ORTEK - Hama
#define IRMP_TELEFUNKEN_PROTOCOL 34 // Telefunken (1560)
#define IRMP_ROOMBA_PROTOCOL 35 // iRobot Roomba vacuum cleaner
#define IRMP_RCMM32_PROTOCOL 36 // Fujitsu-Siemens (Activy remote control)
#define IRMP_RCMM24_PROTOCOL 37 // Fujitsu-Siemens (Activy keyboard)
#define IRMP_RCMM12_PROTOCOL 38 // Fujitsu-Siemens (Activy keyboard)
#define IRMP_SPEAKER_PROTOCOL 39 // Another loudspeaker protocol, similar to Nubert
#define IRMP_LGAIR_PROTOCOL 40 // LG air conditioner
#define IRMP_SAMSUNG48_PROTOCOL 41 // air conditioner with SAMSUNG protocol (48 bits)
#define IRMP_MERLIN_PROTOCOL 42 // Merlin (Pollin 620 185)
#define IRMP_PENTAX_PROTOCOL 43 // Pentax camera
#define IRMP_FAN_PROTOCOL 44 // FAN (ventilator), very similar to NUBERT, but last bit is data bit instead of stop bit
#define IRMP_S100_PROTOCOL 45 // very similar to RC5, but 14 instead of 13 data bits
#define IRMP_ACP24_PROTOCOL 46 // Stiebel Eltron ACP24 air conditioner
#define IRMP_TECHNICS_PROTOCOL 47 // Technics, similar to Matsushita, but 22 instead of 24 bits
#define IRMP_PANASONIC_PROTOCOL 48 // Panasonic (Beamer), start bits similar to KASEIKYO
#define IRMP_MITSU_HEAVY_PROTOCOL 49 // Mitsubishi-Heavy Aircondition, similar timing as Panasonic beamer
#define IRMP_VINCENT_PROTOCOL 50 // Vincent
#define IRMP_SAMSUNGAH_PROTOCOL 51 // SAMSUNG AH
#define IRMP_IRMP16_PROTOCOL 52 // IRMP specific protocol for data transfer, e.g. between two microcontrollers via IR
#define IRMP_GREE_PROTOCOL 53 // Gree climate
#define IRMP_RCII_PROTOCOL 54 // RC II Infra Red Remote Control Protocol for FM8
#define IRMP_METZ_PROTOCOL 55 // METZ
#define IRMP_ONKYO_PROTOCOL 56 // Onkyo

#define RF_GEN24_PROTOCOL 57 // RF Generic, 24 Bits (Pollin 550666)
#define RF_X10_PROTOCOL 58 // RF PC X10 Remote Control (Medion, Pollin 721815)

</syntaxhighlight>

Die Werte für die Adresse und das Kommando muss man natürlich einmal für eine unbekannte Fernbedienung auslesen und dann über ein UART oder LC-Display ausgeben, um sie dann im Programm hart zu kodieren. Oder man hat eine kleine Anlernroutine, wo man einmal die gewünschten Tasten drücken muss, um sie anschließend im EEPROM abzuspeichern. Ein Beispiel dazu findet man im Artikel [http://www.mikrocontroller.net/articles/DIY_Lernfähige_Fernbedienung_mit_IRMP Lernfähige IR-Fernbedienung mit IRMP].

Eine weitere [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-avr.c?view=markup Beispiel-Main-Funktion] ist im Zip-File enthalten, da sieht man dann auch die Initialisierung des Timers.

=== "Entprellen" von Tasten ===

Um zu unterscheiden, ob eine Taste lange gedrückt wurde oder lediglich einzeln, dient das Bit IRMP_FLAG_REPETITION. Dieses wird im Struct-Member '''flags''' gesetzt, wenn eine Taste auf der Fernbedienung längere Zeit gedrückt wurde und dadurch immer wieder dasselbe Kommando innerhalb kurzer Zeitabstände ausgesandt wird.

Beispiel:

<syntaxhighlight lang="c">
if (irmp_data.flags & IRMP_FLAG_REPETITION)
{
// Benutzer hält die Taste länger runter
// entweder:
// ich ignoriere die (Wiederholungs-)Taste
// oder:
// ich benutze diese Info, um einen Repeat-Effekt zu nutzen
}
else
{
// Es handelt sich um eine neue Taste
}
</syntaxhighlight>

Dies kann zum Beispiel dafür genutzt werden, um die Tasten 0-9 zu "entprellen", indem man Kommandos mit gesetztem Bit IRMP_FLAG_REPETITION ignoriert. Bei dem Drücken auf die Tasten VOLUME+ oder VOLUME- kann die wiederholte Auswertung ein und desselben Kommandos aber durchaus gewünscht sein - zum Beispiel, um [[LED-Fading|LEDs zu faden]].

Wenn man nur Einzeltasten auswerten will, kann man obigen IF-Block reduzieren auf:

<syntaxhighlight lang="c">
if (! (irmp_data.flags & IRMP_FLAG_REPETITION))
{
// Es handelt sich um eine neue Taste
// ACTION!
}
</syntaxhighlight>

'''NEU:'''

Seit der Version 3.2.2 gibt es die Möglichkeit, das Loslassen einer Taste zu detektieren. In diesem Fall wird das Flag IRMP_FLAG_RELEASE gesetzt, wenn die verwendete Fernbedienung das (wiederholte) Senden der IR- oder RF-Frames eingestellt hat.

Ein Beispiel:

<syntaxhighlight lang="c">
IRMP_DATA irmp_data;

while (1)
{
if (irmp_get_data (&irmp_data))
{
if (irmp_data.protocol == NEC_PROTOCOL && irmp_data.address == 0x1234)
{
if (irmp_data.command == 0x42 && irmp_data.flags == 0x00) // Erster Frame, flags nicht gesetzt
{
motor_on ();
}
else if (irmp_data.flags & IRMP_FLAG_RELEASE) // Taste wurde losgelassen
{
motor_off ();
}
}
}
}
</syntaxhighlight>

Beim obigen Beispiel wird ein Motor eingeschaltet, sobald man eine bestimmte Taste auf der Fernbedienung drückt. Der Motor wird dann erst wieder gestoppt, wenn man die Taste wieder loslässt.

'''Wichtig beim Prüfen von IRMP_FLAG_RELEASE:'''

Man darf sich nicht darauf verlassen, dass irmp_data.command dabei noch den ursprünglichen Kommando-Code enthält - hier also 0x42. Es gibt nämlich Fernbedienungen (zum Beispiel Funksteckdosen-Sender), welche selbst einen speziellen Key-Release-Code senden, wenn die Taste losgelassen wurde. Also prüft man lediglich die Übereinstimmung von irmp_data.address, bevor man das Flag testet.

'''Dieses Feature muss explizit in irmpconfig.h durch Ändern der Konfigurationsvariablen IRMP_ENABLE_RELEASE_DETECTION freigeschaltet werden!'''

== Arbeitsweise ==

Das "Working Horse" von [[IRMP#top|IRMP]] ist die Interrupt Service Routine irmp_ISR() welche 15.000 mal pro Sekunde aufgerufen werden sollte. Weicht dieser Wert ab, muss die Preprocessor-Konstante [[IRMP#F_INTERRUPTS|F_INTERRUPTS]] in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] angepasst werden. Der Wert kann zwischen 10kHz und 20kHz eingestellt werden.

irmp_ISR() detektiert zunächst die Länge und die Form des/der Startbits und ermittelt daraus das verwendete Protokoll. Sobald das Protokoll erkannt wurde, werden die weiter einzulesenden Bits parametrisiert, um dann möglichst effektiv in den weiteren Aufrufen das komplette IR-Telegramm einzulesen.

Um direkt Kritikern den Wind aus den Segeln zu nehmen:

Ich weiss, die ISR ist ziemlich groß. Aber da sie sich wie eine State Machine verhält, ist der tatsächlich ausgeführte Code pro Durchlauf relativ gering. Solange es "dunkel" ist (und das ist es ja die meiste Zeit ;-)) ist die aufgewendete Zeit sogar verschwindend gering. Im WordClock-Projekt werden mit ein- und demselben Timer 8 ISRs aufgerufen, davon ist die irmp_ISR() nur eine unter vielen. Bei mindestens 8 MHz CPU-Takt traten bisher keine Timing-Probleme auf. Daher sehe ich bei der Länge von irmp_ISR überhaupt kein Problem.

Ein Quarz ist nicht unbedingt notwendig, es funktioniert auch mit dem internen Oszillator des AVRs, wenn man die Prescaler-Fuse entsprechend gesetzt hat, dass die CPU auch mit 8MHz rennt ... Die Fuse-Werte für einen ATMEGA88 findet man in [http://www.mikrocontroller.net/svnbrowser/irmp/irmp-main-avr.c?view=markup irmp-main-avr.c].

== Scannen von unbekannten IR-Protokollen ==

Stellt man in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] in der Zeile

<syntaxhighlight lang="c">
#define IRMP_LOGGING 0 // 1: log IR signal (scan), 0: do not (default)
</syntaxhighlight>

den Wert für [[IRMP#IRMP_LOGGING|IRMP_LOGGING]] auf 1, wird in [[IRMP#top|IRMP]] eine Protokollierung eingeschaltet: Es werden dann die Hell- und Dunkelphase auf dem UART des Microntrollers mit 9600Bd ausgegeben: 1=Dunkel, 0=Hell. Eventuell müssen dann die Konstanten in den Funktionen uart_init() und uart_putc() angepasst werden; das kommt auf den verwendeten AVR-µC an.

'''Hinweis: Für PIC-Prozessoren gibt es ein eigenes Logging-Modul namens [http://www.mikrocontroller.net/svnbrowser/irmp/irmpextlog.c?view=markup irmpextlog.c]. Dieses ermöglicht das Logging über USB. Für AVR-Prozessoren ist [http://www.mikrocontroller.net/svnbrowser/irmp/irmpextlog.c?view=markup irmpextlog.c] irrelevant'''

Nimmt man diese Protokoll-Scans mit einem Terminal-Emulationsprogramm auf und speichert sie dann als normale Datei ab, kann man diese Scan-Dateien zur Analyse verwenden, um damit [[IRMP#top|IRMP]] an das unbekannte Protokoll anzupassen - siehe nächstes Kapitel.

Wer eine Fernbedienung hat, die nicht von [[IRMP#top|IRMP]] unterstützt wird, kann mir ([http://www.mikrocontroller.net/user/show/ukw ukw]) gern die Scan-Dateien zuschicken. Ich schaue dann, ob das Protokoll in das IRMP-Konzept passt und passe gegebenenfalls den Source an.

== IRMP unter Linux und Windows ==

=== Übersetzen ===

[http://www.mikrocontroller.net/svnbrowser/irmp/irmp.c?view=markup irmp.c] lässt sich auch unter Linux direkt kompilieren, um damit Infrarot-Scans, welche in Dateien gespeichert sind, direkt zu testen. Im Unterordner IR-Data finden sich solche Dateien, die man dem [[IRMP#top|IRMP]] direkt zum "Fraß" vorwerfen kann.

Das Übersetzen von [[IRMP#top|IRMP]] geht folgendermaßen:

make -f makefile.lnx

Dabei werden 3 IRMP-Versionen erzeugt:

* irmp-10kHz: Version für 10kHz Scans
* irmp-15kHz: Version für 15kHz Scans
* irmp-20kHz: Version für 20kHz Scans

=== Aufruf von IRMP ===

Der Aufruf geschieht dann über:

./irmp-nnkHz [-l|-p|-a|-v] < scan-file

Die angegebenen Optionen schließen sich aus, das heisst, es kann jeweils nur eine Option zu einer Zeit angegeben werden:

Option:

-l List gibt eine Liste der Pulse und Pausen aus
-a analyze analysiert die Puls-/Pausen und schreibt ein "Spektrum" in ASCII-Form
-v verbose ausführliche Ausgabe
-p Print Timings gibt für alle Protokolle eine Timing-Tabelle aus

Beispiele:

=== Normale Ausgabe ===

./irmp-10kHz < IR-Data/orion_vcr_07660BM070.txt

<syntaxhighlight lang="c">
-------------------------------------------------------------------------
# Taste 1
00000001110111101000000001111111 p = 2, a = 0x7b80, c = 0x0001, f = 0x00
-------------------------------------------------------------------------
# Taste 2
00000001110111100100000010111111 p = 2, a = 0x7b80, c = 0x0002, f = 0x00
-------------------------------------------------------------------------
# Taste 3
00000001110111101100000000111111 p = 2, a = 0x7b80, c = 0x0003, f = 0x00
-------------------------------------------------------------------------
# Taste 4
00000001110111100010000011011111 p = 2, a = 0x7b80, c = 0x0004, f = 0x00
-------------------------------------------------------------------------
...
</syntaxhighlight>

=== Listen-Ausgabe ===

./irmp-10kHz -l < IR-Data/orion_vcr_07660BM070.txt

<syntaxhighlight lang="c">
# Taste 1
pulse: 91 pause: 44
pulse: 6 pause: 5
pulse: 6 pause: 6
pulse: 6 pause: 5
pulse: 6 pause: 5
pulse: 6 pause: 5
pulse: 6 pause: 6
pulse: 6 pause: 5
pulse: 6 pause: 16
...
</syntaxhighlight>

=== Analyse ===

./irmp-10kHz -a < IR-Data/orion_vcr_07660BM070.txt

<pre>
-------------------------------------------------------------------------------
START PULSES:
90 o 1
91 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo 33
92 ooo 2
pulse avg: 91.0=9102.8 us, min: 90=9000.0 us, max: 92=9200.0 us, tol: 1.1%
-------------------------------------------------------------------------------
START PAUSES:
43 oo 1
44 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo 25
45 oooooooooooooooooooooooo 10
pause avg: 44.2=4425.0 us, min: 43=4300.0 us, max: 45=4500.0 us, tol: 2.8%
-------------------------------------------------------------------------------
PULSES:
5 o 17
6 ooooooooooooooooooooooooooooooooooooooooooooooooooooooo 562
7 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo 609
pulse avg: 6.5= 649.8 us, min: 5= 500.0 us, max: 7= 700.0 us, tol: 23.1%
-------------------------------------------------------------------------------
PAUSES:
4 ooooooooooooooooooooooo 169
5 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooo 412
6 oooo 31
pause avg: 4.8= 477.5 us, min: 4= 400.0 us, max: 6= 600.0 us, tol: 25.7%
15 oooooo 43
16 oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo 425
17 oooooooooo 72
pause avg: 16.1=1605.4 us, min: 15=1500.0 us, max: 17=1700.0 us, tol: 6.6%
-------------------------------------------------------------------------------
</pre>

Hier sieht man die gemessenen Zeiten aller Pulse und Pausen als (liegende) Glockenkurven, welche natürlich wegen der ASCII-Darstellung nicht gerade einer Idealkurve entsprechen. Je schmaler die gemessenen Kanäle, desto besser ist das Timing der Fernbedienung.

Aus obigem Output kann man herauslesen:

* Das Start-Bit hat eine Pulslänge zwischen 9000 und 9200 usec, im Mittel sind es 9102 usec. Die Abweichung von diesem Mittelwert liegt bei 1,1 Prozent.

* Das Start-Bit hat eine Pausenlänge zwischen 4300 usec und 4500 usec, der Mittelwert beträgt 4424 usec. Der Fehler liegt bei 2,8 Prozent.

* Die Pulslänge eines Datenbits liegt zwischen 500 usec und 700 usec, im Mittel sind es 650 usec, der Fehler liegt bei (stolzen) 23,1 Prozent!

Desweiteren gibt es noch 2 verschieden lange Pausen (für die Bits 0 und 1), das Ablesen der Werte überlasse ich dem geneigten Leser ;-)

=== Ausführliche Ausgabe ===

./irmp-10kHz -v < IR-Data/orion_vcr_07660BM070.txt

<pre>
-------------------------------------------------------------------------------
# 1 - IR-cmd: 0x0001
0.200ms [starting pulse]
13.700ms [start-bit: pulse = 91, pause = 44]
protocol = NEC, start bit timings: pulse: 62 - 118, pause: 30 - 60
pulse_1: 3 - 8
pause_1: 11 - 23
pulse_0: 3 - 8
pause_0: 3 - 8
command_offset: 16
command_len: 16
complete_len: 32
stop_bit: 1
14.800ms [bit 0: pulse = 6, pause = 5] 0
16.000ms [bit 1: pulse = 6, pause = 6] 0
17.100ms [bit 2: pulse = 6, pause = 5] 0
18.200ms [bit 3: pulse = 6, pause = 5] 0
19.300ms [bit 4: pulse = 6, pause = 5] 0
20.500ms [bit 5: pulse = 6, pause = 6] 0
21.600ms [bit 6: pulse = 6, pause = 5] 0
23.800ms [bit 7: pulse = 6, pause = 16] 1
26.100ms [bit 8: pulse = 6, pause = 17] 1
28.300ms [bit 9: pulse = 6, pause = 16] 1
29.500ms [bit 10: pulse = 6, pause = 6] 0
31.700ms [bit 11: pulse = 6, pause = 16] 1
34.000ms [bit 12: pulse = 6, pause = 17] 1
36.200ms [bit 13: pulse = 6, pause = 16] 1
38.500ms [bit 14: pulse = 6, pause = 17] 1
39.600ms [bit 15: pulse = 6, pause = 5] 0
41.900ms [bit 16: pulse = 6, pause = 17] 1
43.000ms [bit 17: pulse = 6, pause = 5] 0
44.100ms [bit 18: pulse = 6, pause = 5] 0
45.200ms [bit 19: pulse = 6, pause = 5] 0
46.400ms [bit 20: pulse = 7, pause = 5] 0
47.500ms [bit 21: pulse = 6, pause = 5] 0
48.600ms [bit 22: pulse = 6, pause = 5] 0
49.800ms [bit 23: pulse = 6, pause = 6] 0
50.900ms [bit 24: pulse = 5, pause = 6] 0
53.100ms [bit 25: pulse = 6, pause = 16] 1
55.400ms [bit 26: pulse = 6, pause = 17] 1
57.600ms [bit 27: pulse = 6, pause = 16] 1
59.900ms [bit 28: pulse = 6, pause = 17] 1
62.100ms [bit 29: pulse = 6, pause = 16] 1
64.400ms [bit 30: pulse = 6, pause = 17] 1
66.700ms [bit 31: pulse = 6, pause = 17] 1
stop bit detected
67.300ms code detected, length = 32
67.300ms p = 2, a = 0x7b80, c = 0x0001, f = 0x00
-------------------------------------------------------------------------------
</pre>

=== Aufruf unter Windows ===

[[IRMP#top|IRMP]] kann man auch unter Windows nutzen, nämlich folgendermaßen:

* Eingabeaufforderung starten
* In das Verzeichnis irmp wechseln
* Aufruf von:
irmp-10kHz.exe < IR-Data\rc5x.txt

Es gelten dieselben Optionen wie für die Linux-Version.

=== Längere Ausgaben ===

Da manche Ausgaben sehr lang werden, empfiehlt es sich auch hier, die Ausgabe in eine Datei zu lenken oder in einen Pager weiterzuleiten, damit man seitenweise blättern kann:

Linux:

./irmp-10kHz < IR-Data/rc5x.txt | less

Windows:

irmp-10kHz.exe < IR-Data\rc5x.txt | more

== Fernbedienungen ==

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! Protokoll || Bezeichnung || Gerät || Device Address
|-
| [[IRMP#NEC_+_extended_NEC|NEC]] || Toshiba CT-9859 || Fernseher || 0x5F40
|-
| || Toshiba VT-728G || V-728G Videorekorder || 0x5B44
|-
| || Elta 8848 MP 4 || DVD-Player || 0x7F00
|-
| || AS-218 || Askey TV-View CHP03X (TV-Karte) || 0x3B86
|-
| || Cyberhome ??? || Cyberhome DVD Player || 0x6D72
|-
| || WD TV Live || Western Digital Multimediaplayer || 0x1F30
|-
| || Canon WL-DC100 || Kamera Canon PowerShot G5 || 0xB1CA
|-
| || Bleil LED Flex-Band RGB || RGB-LED Band mit IR-Controller || 0xFE00
|-
| [[IRMP#NEC16|NEC16]] || Daewoo || Videorekorder || 0x0015
|-
| [[IRMP#KASEIKYO|KASEIKYO]] || Technics EUR646497 || AV Receiver SA-AX 730 || 0x2002
|-
| || Panasonic TV || Fernseher TX-L32EW6 || 0x2002
|-
| [[IRMP#RC5_+_RC5X|RC5]] || Loewe Assist/RC3/RC4 || Fernseher (FB auf TV-Mode) || 0x0000
|-
| [[IRMP#RC6_+_RC6A|RC6]] || Philips Television || Fernseher (FB auf TV-Mode) || 0x0000
|-
| [[IRMP#SIRCS|SIRCS]] || Sony RM-816 || Fernseher (FB auf TV-Mode) || 0x0000
|-
| [[IRMP#DENON|DENON]] || DENON RC970 || AVR3805 (Verstärker) || 0x0008
|-
| || DENON RC970 || DVD/CD-Player || 0x0002
|-
| || DENON RC970 || Tuner || 0x0006
|-
| [[IRMP#SAMSUNG32|SAMSUNG32]] || Samsung AA59-00484A || LE40D550 Fernseher || 0x0707
|-
| || LG AKB72033901 || Blu-Ray Player BD370 || 0x2D2D
|-
| [[IRMP#APPLE|APPLE]] || Apple || Apple Dock (iPod 2) || 0x0020
|-
|}

----

== Kameras ==

[[Datei:Irmp-pentax.png|miniatur|Pentax-Protokoll]]

[[IRMP#top|IRMP]] unterstützt zunehmend auch die Fernsteuerung von Kameras, nämlich:

* [[IRMP#PENTAX|PENTAX]]
* [[IRMP#NIKON|NIKON]]

Die Kommando-Vielfalt ist nicht gerade groß. Normalerweise verstehen die Kameras gerade mal das Kommando "Auslösen".

Hier eine kleine Tabelle für [[IRMP#PENTAX|PENTAX]]-Kameras:

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! Kommando || Funktion
|-
| 0x0000 || Auslösen
|-
| 0x0001 || Zoomlevel umschalten
|-
|}

Da keine Adresse im [[IRMP#PENTAX|PENTAX]]-Protokoll vorgesehen ist, sollte man am diese beim Senden mittels [[IRSND]] am besten auf 0x0000 setzen. Ebenso sollte man in diesem Fall einen Quarz verwenden, da gerade die Nikons bezüglich des Timings sehr penibel sind.

== IR-Tastaturen ==

[[Datei:irmp-fdc3402.jpg|miniatur|FDC-3402-Tastatur]]

[[IRMP#top|IRMP]] unterstützt ab Version 1.7.0 auch IR-Tastaturen, nämlich die Infrarot-Tastatur FDC-3402 - <s>erhältlich bei Pollin (Art. 711 056) für weniger als 2 EUR.</s> (Vergriffen, Stand 19.09.2017)

Beim Erkennen einer Taste gibt [[IRMP#top|IRMP]] folgende Daten zurück:

Protokoll-Nummer (irmp_data.protocol): 18
Addresse (irmp_data.address): 0x003F

Als Kommando (irmp_data.command) werden folgende Werte zurückgeliefert:

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! Code || Taste || Code || Taste || Code || Taste || Code || Taste || Code || Taste || Code || Taste || Code || Taste || Code || Taste
|-
| 0x0000 || || 0x0010 || TAB || 0x0020 || 's' || 0x0030 || 'c' || 0x0040 || || 0x0050 || HOME || 0x0060 || || 0x0070 || MENUE
|-
| 0x0001 || '^' || 0x0011 || 'q' || 0x0021 || 'd' || 0x0031 || 'v' || 0x0041 || || 0x0051 || END || 0x0061 || || 0x0071 || BACK
|-
| 0x0002 || '1' || 0x0012 || 'w' || 0x0022 || 'f' || 0x0032 || 'b' || 0x0042 || || 0x0052 || || 0x0062 || || 0x0072 || FORWARD
|-
| 0x0003 || '2' || 0x0013 || 'e' || 0x0023 || 'g' || 0x0033 || 'n' || 0x0043 || || 0x0053 || UP || 0x0063 || || 0x0073 || ADDRESS
|-
| 0x0004 || '3' || 0x0014 || 'r' || 0x0024 || 'h' || 0x0034 || 'm' || 0x0044 || || 0x0054 || DOWN || 0x0064 || || 0x0074 || WINDOW
|-
| 0x0005 || '4' || 0x0015 || 't' || 0x0025 || 'j' || 0x0035 || ',' || 0x0045 || || 0x0055 || PAGE_UP || 0x0065 || || 0x0075 || 1ST_PAGE
|-
| 0x0006 || '5' || 0x0016 || 'z' || 0x0026 || 'k' || 0x0036 || '.' || 0x0046 || || 0x0056 || PAGE_DOWN || 0x0066 || || 0x0076 || STOP
|-
| 0x0007 || '6' || 0x0017 || 'u' || 0x0027 || 'l' || 0x0037 || '-' || 0x0047 || || 0x0057 || || 0x0067 || || 0x0077 || MAIL
|-
| 0x0008 || '7' || 0x0018 || 'i' || 0x0028 || 'ö' || 0x0038 || || 0x0048 || || 0x0058 || || 0x0068 || || 0x0078 || FAVORITES
|-
| 0x0009 || '8' || 0x0019 || 'o' || 0x0029 || 'ä' || 0x0039 || SHIFT_RIGHT || 0x0049 || || 0x0059 || RIGHT || 0x0069 || || 0x0079 || NEW_PAGE
|-
| 0x000A || '9' || 0x001A || 'p' || 0x002A || '#' || 0x003A || CTRL || 0x004A || || 0x005A || || 0x006A || || 0x007A || SETUP
|-
| 0x000B || '0' || 0x001B || 'ü' || 0x002B || CR || 0x003B || || 0x004B || INSERT || 0x005B || || 0x006B || || 0x007B || FONT
|-
| 0x000C || 'ß' || 0x001C || '+' || 0x002C || SHIFT_LEFT || 0x003C || ALT_LEFT || 0x004C || DELETE || 0x005C || || 0x006C || || 0x007C || PRINT
|-
| 0x000D || '´' || 0x001D || || 0x002D || '<' || 0x003D || SPACE || 0x004D || || 0x005D || || 0x006D || || 0x007D ||
|-
| 0x000E || || 0x001E || CAPSLOCK || 0x002E || 'y' || 0x003E || ALT_RIGHT || 0x004E || || 0x005E || || 0x006E || ESCAPE || 0x007E || ON_OFF
|-
| 0x000F || BACKSPACE || 0x001F || 'a' || 0x002F || 'x' || 0x003F || || 0x004F || LEFT || 0x005F || || 0x006F || || 0x007F ||
|-
|}

Zusatztasten links:

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! Code || Taste
|-
|-
| 0x0400 || KEY_MOUSE_1
|-
| 0x0800 || KEY_MOUSE_2
|}

Dabei gelten die obigen Werte für das Drücken einer Taste. Wird die Taste wieder losgelassen, setzt [[IRMP#top|IRMP]] zusätzlich das 8. Bit im Kommando.

Beispiel:

Taste 'a' drücken: 0x001F
Taste 'a' loslassen: 0x009F

Ausnahme ist die EIN/AUS-Taste: Diese sendet nur beim Drücken einen Code, nicht beim Loslassen.

Wird eine Taste länger gedrückt, wird das in irmp_data.flag angezeigt.

Beispiel:

command flag
Taste 'a' drücken: 0x001F 0x00
Taste 'a' drücken: 0x001F 0x01
Taste 'a' drücken: 0x001F 0x01
Taste 'a' drücken: 0x001F 0x01
....
Taste 'a' loslassen: 0x009F 0x00

Werden Tastenkombinationen (zum Beispiel für ein großes 'A') gedrückt, dann sind die Rückgabewerte von [[IRMP#top|IRMP]] in folgendem Ablauf zu sehen:

Linke SHIFT-Taste drücken: 0x0002
Taste 'a' drücken: 0x001F
Taste 'a' loslassen: 0x009F
Linke SHIFT-Taste loslassen: 0x0082

In [http://www.mikrocontroller.net/svnbrowser/irmp/irmp.c?view=markup irmp.c] findet man für die LINUX-Version eine Funktion get_fdc_key(), welche als Vorlage dienen mag, die Keycodes einer FDC-Tastatur in die entsprechenden ASCII-Codes umzuwandeln. Diese Funktion kann man entweder lokal auf dem µC nutzen, um die Keycodes zu decodieren, oder auf einem Hostsystem (z.B. PC), an welches die IRMP-Data-Struktur gesandt wird. Dafür sollte man die Funktion incl. der dazugehörenden Preprozessor-Konstanten in seinen Applikations-Quelltext kopieren.

Hier der entsprechende Auszug:
<syntaxhighlight lang="c">
#define STATE_LEFT_SHIFT 0x01
#define STATE_RIGHT_SHIFT 0x02
#define STATE_LEFT_CTRL 0x04
#define STATE_LEFT_ALT 0x08
#define STATE_RIGHT_ALT 0x10

#define KEY_ESCAPE 0x1B // keycode = 0x006e
#define KEY_MENUE 0x80 // keycode = 0x0070
#define KEY_BACK 0x81 // keycode = 0x0071
#define KEY_FORWARD 0x82 // keycode = 0x0072
#define KEY_ADDRESS 0x83 // keycode = 0x0073
#define KEY_WINDOW 0x84 // keycode = 0x0074
#define KEY_1ST_PAGE 0x85 // keycode = 0x0075
#define KEY_STOP 0x86 // keycode = 0x0076
#define KEY_MAIL 0x87 // keycode = 0x0077
#define KEY_FAVORITES 0x88 // keycode = 0x0078
#define KEY_NEW_PAGE 0x89 // keycode = 0x0079
#define KEY_SETUP 0x8A // keycode = 0x007a
#define KEY_FONT 0x8B // keycode = 0x007b
#define KEY_PRINT 0x8C // keycode = 0x007c
#define KEY_ON_OFF 0x8E // keycode = 0x007c

#define KEY_INSERT 0x90 // keycode = 0x004b
#define KEY_DELETE 0x91 // keycode = 0x004c
#define KEY_LEFT 0x92 // keycode = 0x004f
#define KEY_HOME 0x93 // keycode = 0x0050
#define KEY_END 0x94 // keycode = 0x0051
#define KEY_UP 0x95 // keycode = 0x0053
#define KEY_DOWN 0x96 // keycode = 0x0054
#define KEY_PAGE_UP 0x97 // keycode = 0x0055
#define KEY_PAGE_DOWN 0x98 // keycode = 0x0056
#define KEY_RIGHT 0x99 // keycode = 0x0059
#define KEY_MOUSE_1 0x9E // keycode = 0x0400
#define KEY_MOUSE_2 0x9F // keycode = 0x0800

static uint8_t
get_fdc_key (uint16_t cmd)
{
static uint8_t key_table[128] =
{
// 0 1 2 3 4 5 6 7 8 9 A B C D E F
0, '^', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 0xDF, '´', 0, '\b',
'\t', 'q', 'w', 'e', 'r', 't', 'z', 'u', 'i', 'o', 'p', 0xFC, '+', 0, 0, 'a',
's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 0xF6, 0xE4, '#', '\r', 0, '<', 'y', 'x',
'c', 'v', 'b', 'n', 'm', ',', '.', '-', 0, 0, 0, 0, 0, ' ', 0, 0,

0, '°', '!', '"', '§', '$', '%', '&', '/', '(', ')', '=', '?', '`', 0, '\b',
'\t', 'Q', 'W', 'E', 'R', 'T', 'Z', 'U', 'I', 'O', 'P', 0xDC, '*', 0, 0, 'A',
'S', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 0xD6, 0xC4, '\'', '\r', 0, '>', 'Y', 'X',
'C', 'V', 'B', 'N', 'M', ';', ':', '_', 0, 0, 0, 0, 0, ' ', 0, 0
};
static uint8_t state;

uint8_t key = 0;

switch (cmd)
{
case 0x002C: state |= STATE_LEFT_SHIFT; break; // pressed left shift
case 0x00AC: state &= ~STATE_LEFT_SHIFT; break; // released left shift
case 0x0039: state |= STATE_RIGHT_SHIFT; break; // pressed right shift
case 0x00B9: state &= ~STATE_RIGHT_SHIFT; break; // released right shift
case 0x003A: state |= STATE_LEFT_CTRL; break; // pressed left ctrl
case 0x00BA: state &= ~STATE_LEFT_CTRL; break; // released left ctrl
case 0x003C: state |= STATE_LEFT_ALT; break; // pressed left alt
case 0x00BC: state &= ~STATE_LEFT_ALT; break; // released left alt
case 0x003E: state |= STATE_RIGHT_ALT; break; // pressed left alt
case 0x00BE: state &= ~STATE_RIGHT_ALT; break; // released left alt

case 0x006e: key = KEY_ESCAPE; break;
case 0x004b: key = KEY_INSERT; break;
case 0x004c: key = KEY_DELETE; break;
case 0x004f: key = KEY_LEFT; break;
case 0x0050: key = KEY_HOME; break;
case 0x0051: key = KEY_END; break;
case 0x0053: key = KEY_UP; break;
case 0x0054: key = KEY_DOWN; break;
case 0x0055: key = KEY_PAGE_UP; break;
case 0x0056: key = KEY_PAGE_DOWN; break;
case 0x0059: key = KEY_RIGHT; break;
case 0x0400: key = KEY_MOUSE_1; break;
case 0x0800: key = KEY_MOUSE_2; break;

default:
{
if (!(cmd & 0x80)) // pressed key
{
if (cmd >= 0x70 && cmd <= 0x7F) // function keys
{
key = cmd + 0x10; // 7x -> 8x
}
else if (cmd < 64) // key listed in key_table
{
if (state & (STATE_LEFT_ALT | STATE_RIGHT_ALT))
{
switch (cmd)
{
case 0x0003: key = 0xB2; break; // ²
case 0x0008: key = '{'; break;
case 0x0009: key = '['; break;
case 0x000A: key = ']'; break;
case 0x000B: key = '}'; break;
case 0x000C: key = '\\'; break;
case 0x001C: key = '~'; break;
case 0x002D: key = '|'; break;
case 0x0034: key = 0xB5; break; // µ
}
}
else if (state & (STATE_LEFT_CTRL))
{
if (key_table[cmd] >= 'a' && key_table[cmd] <= 'z')
{
key = key_table[cmd] - 'a' + 1;
}
else
{
key = key_table[cmd];
}
}
else
{
int idx = cmd + ((state & (STATE_LEFT_SHIFT | STATE_RIGHT_SHIFT)) ? 64 : 0);

if (key_table[idx])
{
key = key_table[idx];
}
}
}
}
break;
}
}

return (key);
}
</syntaxhighlight>

Als letztes noch ein Beispiel einer Anwendung der Funktion get_fdc_key():

<syntaxhighlight lang="c">
if (irmp_get_data (&irmp_data))
{
uint8_t key;

if (irmp_data.protocol == IRMP_FDC_PROTOCOL &&
(key = get_fdc_key (irmp_data.command)) != 0)
{
if ((key >= 0x20 && key < 0x7F) || key >= 0xA0) // show only printable characters
{
printf ("ascii-code = 0x%02x, character = '%c'\n", key, key);
}
else // it's a non-printable key
{
printf ("ascii-code = 0x%02x\n", key);
}
}
}
</syntaxhighlight>

Alle nicht-druckbaren Zeichen werden dabei folgendermaßen codiert:

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! Taste || Konstante || Wert
|-
| ESC || KEY_ESCAPE || 0x1B
|-
| Menü || KEY_MENUE || 0x80
|-
| Zurück || KEY_BACK || 0x81
|-
| Vorw. || KEY_FORWARD || 0x82
|-
| Adresse || KEY_ADDRESS || 0x83
|-
| Fenster || KEY_WINDOW || 0x84
|-
| 1. Seite || KEY_1ST_PAGE || 0x85
|-
| Stop || KEY_STOP || 0x86
|-
| Mail || KEY_MAIL || 0x87
|-
| Fav. || KEY_FAVORITES || 0x88
|-
| Neue Seite || KEY_NEW_PAGE || 0x89
|-
| Setup || KEY_SETUP || 0x8A
|-
| Schrift || KEY_FONT || 0x8B
|-
| Druck || KEY_PRINT || 0x8C
|-
| Ein/Aus || KEY_ON_OFF || 0x8E
|-
| Backspace || '\b' || 0x08
|-
| CR/ENTER || '\r' || 0x0C
|-
| TAB || '\t' || 0x09
|-
| Einfg || KEY_INSERT || 0x90
|-
| Entf || KEY_DELETE || 0x91
|-
| Cursor links || KEY_LEFT || 0x92
|-
| Pos1 || KEY_HOME || 0x93
|-
| Ende || KEY_END || 0x94
|-
| Cursor rechts || KEY_UP || 0x95
|-
| Cursor runter || KEY_DOWN || 0x96
|-
| Bild hoch || KEY_PAGE_UP || 0x97
|-
| Bild runter || KEY_PAGE_DOWN || 0x98
|-
| Cursor links || KEY_RIGHT || 0x99
|-
| Linke Maustaste || KEY_MOUSE_1 || 0x9E
|-
| Rechte Maustaste || KEY_MOUSE_2 || 0x9F
|-
|}

Die Funktion get_fdc_key berücksichtigt das Gedrückthalten der Shift-, Strg- und ALT-Tasten. Damit funktioniert nicht nur das Schreiben von Großbuchstaben, sondern auch das Auswählen der Sonderzeichen mit der Tastenkombination ALT + Taste, z.B. ALT + m = µ oder ALT + q = @. Ebenso kann man mit der Strg-Taste die Control-Zeichen CTRL-A bis CTRL-Z senden. Die CapsLock-Taste wird ignoriert, da ich sie sowieso für die überflüssigste Taste überhaupt halte ;-)

= Anhang =

== Die IR-Protokolle im Detail ==

=== Pulse Distance Protokolle ===
[[Datei:Pulse-Distance.png|miniatur|Pulse Distance Coding]]
''' '''
''' '''
''' '''
''' '''
''' '''
''' '''
''' '''

==== NEC + extended NEC ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#NEC-Protokoll|NEC + extended NEC]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz / 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 32 Daten-Bits + 1 Stop-Bit
|-
| Daten NEC || 8 Adress-Bits + 8 invertierte Adress-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits
|-
| Daten ext. NEC || 16 Adress-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits
|-
| Start-Bit || 9000µs Puls, 4500µs Pause
|-
| 0-Bit || 560µs Puls, 560µs Pause
|-
| 1-Bit || 560µs Puls, 1690µs Pause
|-
| Stop-Bit || 560µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || 9000µs Puls, 2250µs Pause, 560µs Puls, ~100ms Pause
|-
| Bit-Order || LSB first
|-
|}

==== ONKYO ====

Wie [[IRMP#NEC|ext. NEC]], jedoch 16 unabhängige Datenbits, also:

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#ONKYO-Protokoll|ONKYO]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Daten ONKYO || 16 Adress-Bits + 16 Kommando-Bits
|-
|}

==== JVC ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#NEC16-Protokoll (JVC)|JVC]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 16 Daten-Bits + 1 Stop-Bit
|-
| Daten || 4 Adress-Bits + 12 Kommando-Bits
|-
| Start-Bit || 9000µs Puls, 4500µs Pause, 6000µs Pause bei Tasten-Wiederholung
|-
| 0-Bit || 560µs Puls, 560µs Pause
|-
| 1-Bit || 560µs Puls, 1690µs Pause
|-
| Stop-Bit || 560µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || Wiederholung nach Pause von 25ms
|-
| Bit-Order || LSB first
|-
|}

==== NEC16 ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''NEC16''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 8 Adress-Bits + 1 Sync-Bit + 8 Daten-Bits + 1 Stop-Bit
|-
| Start-Bit || 9000µs Puls, 4500µs Pause
|-
| Sync-Bit || 560µs Puls, 4500µs Pause
|-
| 0-Bit || 560µs Puls, 560µs Pause
|-
| 1-Bit || 560µs Puls, 1690µs Pause
|-
| Stop-Bit || 560µs Puls
|-
| Wiederholung || keine/eine/zwei nach 25ms?
|-
| Tasten-Wiederholung || Wiederholung nach Pause von 25ms?
|-
| Bit-Order || LSB first
|-
|}

==== NEC42 ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''NEC42''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 42 Daten-Bits + 1 Stop-Bit
|-
| Daten || 13 Adress-Bits + 13 invertierte Adress-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits
|-
| Start-Bit || 9000µs Puls, 4500µs Pause
|-
| 0-Bit || 560µs Puls, 560µs Pause
|-
| 1-Bit || 560µs Puls, 1690µs Pause
|-
| Stop-Bit || 560µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || nach 110ms (ab Start-Bit), 9000µs Puls, 2250µs Pause, 560µs Puls
|-
| Bit-Order || LSB first
|-
|}

==== ACP24 ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#ACP24-Protokoll|ACP24]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 70 Daten-Bits + 1 Stop-Bit
|-
| Daten || 0 Adress-Bits + 70 Kommando-Bits
|-
| Start-Bit || 390µs Puls, 950µs Pause
|-
| 0-Bit || 390µs Puls, 950µs Pause
|-
| 1-Bit || 390µs Puls, 1300µs Pause
|-
| Stop-Bit || 390µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first
|-
|}

==== LGAIR ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#LGAIR-Protokoll|LGAIR]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 28 Daten-Bits + 1 Stop-Bit
|-
| Daten || 8 Adress-Bits + 16 Kommando-Bits + 4 Checksum-Bits
|-
| Start-Bit || 9000µs Puls, 4500µs Pause (identisch mit [[IRMP#NEC_.2B_extended_NEC|NEC]])
|-
| 0-Bit || 560µs Puls, 560µs Pause (identisch mit [[IRMP#NEC_.2B_extended_NEC|NEC]])
|-
| 1-Bit || 560µs Puls, 1690µs Pause (identisch mit [[IRMP#NEC_.2B_extended_NEC|NEC]])
|-
| Stop-Bit || 560µs Puls (identisch mit [[IRMP#NEC_.2B_extended_NEC|NEC]])
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first ('''abweichend''' zu [[IRMP#NEC_.2B_extended_NEC|NEC]])
|-
|}

==== SAMSUNG ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#SAMSUNG-Protokoll|SAMSUNG]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || ?? kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 16 Daten(1)-Bits + 1 Sync-Bit + 20 Daten(2)-Bits + 1 Stop-Bit
|-
| Daten(1) || 16 Adress-Bits
|-
| Daten(2) || 4 ID-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits
|-
| Start-Bit || 4500µs Puls, 4500µs Pause
|-
| 0-Bit || 550µs Puls, 550µs Pause
|-
| 1-Bit || 550µs Puls, 1650µs Pause
|-
| Sync-Bit || 550µs Puls, 4500µs Pause
|-
| Stop-Bit || 550µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || LSB first
|-
|}

==== SAMSUNG32 ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''SAMSUNG32''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 32 Daten-Bits + 1 Stop-Bit
|-
| Daten || 16 Adress-Bits + 16 Kommando-Bits
|-
| Start-Bit || 4500µs Puls, 4500µs Pause
|-
| 0-Bit || 550µs Puls, 550µs Pause
|-
| 1-Bit || 550µs Puls, 1650µs Pause
|-
| Stop-Bit || 550µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || Wiederholung nach ca. 47msec
|-
| Bit-Order || LSB first
|-
|}

==== SAMSUNG48 ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''SAMSUNG48''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 48 Daten-Bits + 1 Stop-Bit
|-
| Daten || 16 Adress-Bits + 32 Kommando-Bits
|-
| Kommando || 8 Bits + 8 invertierte Bits + 8 Bits + 8 invertierte Bits
|-
| Start-Bit || 4500µs Puls, 4500µs Pause
|-
| 0-Bit || 550µs Puls, 550µs Pause
|-
| 1-Bit || 550µs Puls, 1650µs Pause
|-
| Stop-Bit || 550µs Puls
|-
| Wiederholung || eine nach ca. 5 msec
|-
| Tasten-Wiederholung || dritter, fünfter, siebter usw. identischer Frame
|-
| Bit-Order || LSB first
|-
|}

==== MATSUSHITA ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#MATSUHITA-Protokoll|MATSUSHITA]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz
|-
| Kodierung || Pulse Distance, Timing identisch mit [[IRMP#TECHNICS|TECHNICS]]
|-
| Frame || 1 Start-Bit + 24 Daten-Bits + 1 Stop-Bit
|-
| Daten || 6 Hersteller-Bits + 6 Kommando-Bits + 12 Adress-Bits
|-
| Start-Bit || 3488µs Puls, 3488µs Pause
|-
| 0-Bit || 872µs Puls, 872µs Pause
|-
| 1-Bit || 872µs Puls, 2616µs Pause
|-
| Stop-Bit || 872µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames nach 40ms Pause
|-
| Bit-Order || LSB first?
|-
|}

==== TECHNICS ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''TECHNICS''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz?
|-
| Kodierung || Pulse Distance, Timing identisch mit [[IRMP#MATSUSHITA|MATSUSHITA]]
|-
| Frame || 1 Start-Bit + 22 Daten-Bits + 1 Stop-Bit
|-
| Daten || 11 Kommando-Bits + 11 invertierte Kommando-Bits
|-
| Start-Bit || 3488µs Puls, 3488µs Pause
|-
| 0-Bit || 872µs Puls, 872µs Pause
|-
| 1-Bit || 872µs Puls, 2616µs Pause
|-
| Stop-Bit || 872µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames nach 40ms Pause
|-
| Bit-Order || LSB first?
|-
|}

==== KASEIKYO ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#KASEIKYO-Protokoll (auch "Japan-Protokoll")|KASEIKYO]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 48 Daten-Bits + 1 Stop-Bit
|-
| Daten || 16 Hersteller-Bits + 4 Parity-Bits + 4 Genre1-Bits + 4 Genre2-Bits + 10 Kommando-Bits + 2 ID-Bits + 8 Parity-Bits
|-
| Start-Bit || 3380µs Puls, 1690µs Pause
|-
| 0-Bit || 423µs Puls, 423µs Pause
|-
| 1-Bit || 423µs Puls, 1269µs Pause
|-
| Stop-Bit || 423µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames nach ca. 80ms Pause
|-
| Bit-Order || LSB first?
|-
|}

==== RECS80 ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#RECS80- und RECS80-Extended-Protokoll|RECS80]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bits + 10 Daten-Bits + 1 Stop-Bit
|-
| Daten || 1 Toggle-Bit + 3 Adress-Bits + 6 Kommando-Bits
|-
| Start-Bit || 158µs Puls, 7432µs Pause
|-
| 0-Bit || 158µs Puls, 4902µs Pause
|-
| 1-Bit || 158µs Puls, 7432µs Pause
|-
| Stop-Bit || 158µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || MSB first
|-
|}

==== RECS80EXT ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#RECS80- und RECS80-Extended-Protokoll|RECS80EXT]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 2 Start-Bits + 11 Daten-Bits + 1 Stop-Bit
|-
| Daten || 1 Toggle-Bit + 4 Adress-Bits + 6 Kommando-Bits
|-
| Start-Bit || 158µs Puls, 3637µs Pause
|-
| 0-Bit || 158µs Puls, 4902µs Pause
|-
| 1-Bit || 158µs Puls, 7432µs Pause
|-
| Stop-Bit || 158µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || MSB first
|-
|}

==== DENON ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#Denon-Protokoll|DENON]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz (in der Praxis, lt. Dokumentation: 32 kHz)
|-
| Kodierung || Pulse Distance
|-
| Frame || 0 Start-Bits + 15 Daten-Bits + 1 Stop-Bit
|-
| Daten || 5 Address-Bits + 10 Kommando-Bits
|-
| Kommando || 6 Datenbits + 2 Extension Bits + 2 Data Construction Bits (*)
|-
| Start-Bit || kein Start-Bit
|-
| 0-Bit || 310µs Puls, 745µs Pause (in der Praxis, lt. Doku: 275µs Puls, 775µs Pause)
|-
| 1-Bit || 310µs Puls, 1780µs Pause (in der Praxis, lt. Doku: 275µs Puls, 1900µs Pause)
|-
| Stop-Bit || 310µs Puls (310µs Puls, 745µs Pause (in der Praxis, lt. Doku: 275µs Puls)
|-
| Wiederholung || Nach 65ms Wiederholung des Frames mit invertieren Kommando-Bits (Data Construction Bits = 11)
|-
| Tasten-Wiederholung || N-fache Wiederholung der beiden Original-Frames nach 65ms
|-
| Bit-Order || MSB first
|-
|}

(*) Data Construction Bits:
* 00 = Erster Frame Denon
* 10 = Erster Frame Sharp
* 01 = Wiederholungsframe Sharp
* 11 = Wiederholungsframe Denon

==== APPLE ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''APPLE''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 32 Daten-Bits + 1 Stop-Bit
|-
| Daten || 16 Adress-Bits + 11100000 + 8 Kommando-Bits
|-
| Start-Bit || siehe [[IRMP#NEC_+_extended_NEC|NEC]]
|-
| 0-Bit || siehe [[IRMP#NEC_+_extended_NEC|NEC]]
|-
| 1-Bit || siehe [[IRMP#NEC_+_extended_NEC|NEC]]
|-
| Stop-Bit || siehe [[IRMP#NEC_+_extended_NEC|NEC]]
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || LSB first
|-
|}

==== BOSE ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''BOSE''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 16 Daten-Bits + 1 Stop-Bit
|-
| Daten || 0 Adress-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits
|-
| Start-Bit || 1060µs Puls, 1425µs Pause
|-
| 0-Bit || 550µs Puls, 437µs Pause
|-
| 1-Bit || 550µs Puls, 1425µs Pause
|-
| Stop-Bit || 550µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || noch ungeklärt
|-
| Bit-Order || LSB first
|-
|}

==== B&O ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#Bang & Olufsen|B&O]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 455 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 4 Start-Bits + 16 Daten-Bits + 1 Trailer-Bit + 1 Stop-Bit
|-
| Daten || 0 Adress-Bits + 16 Kommando-Bits
|-
| Start-Bit 1 || 200µs Puls, 2925µs Pause
|-
| Start-Bit 2 || 200µs Puls, 2925µs Pause
|-
| Start-Bit 3 || 200µs Puls, 15425µs Pause
|-
| Start-Bit 4 || 200µs Puls, 2925µs Pause
|-
| 0-Bit || 200µs Puls, 2925µs Pause
|-
| 1-Bit || 200µs Puls, 9175µs Pause
|-
| R-Bit || 200µs Puls, 6050µs Pause, wiederholt das letzte Bit (repetition)
|-
| Trailer-Bit || 200µs Puls, 12300µs Pause
|-
| Stop-Bit || 200µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || MSB first
|-
|}

==== FDC ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''FDC''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 40 Daten-Bits + 1 Stop-Bit
|-
| Daten || 8 Adress-Bits + 12 x 0-Bits + 4 Press/Release-Bits + 8 Kommando-Bits + 8 invertierte Kommando-Bits
|-
| Start-Bit || 2085µs Puls, 966µs Pause
|-
| 0-Bit || 300µs Puls, 220µs Pause
|-
| 1-Bit || 300µs Puls, 715µs Pause
|-
| Stop-Bit || 300µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Drücken || Press/Release-Bits = 0000
|-
| Tasten-Loslassen || Press/Release-Bits = 1111
|-
| Tasten-Wiederholung || Wiederholung nach Pause von 60ms
|-
| Bit-Order || LSB first
|-
|}

==== NIKON ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''NIKON''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 2 Daten-Bits + 1 Stop-Bit
|-
| Daten || 2 Kommando-Bits
|-
| Start-Bit || 2200µs Puls, 27100µs Pause
|-
| 0-Bit || 500µs Puls, 1500µs Pause
|-
| 1-Bit || 500µs Puls, 3500µs Pause
|-
| Stop-Bit || 500µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first
|-
|}

==== PANASONIC ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''PANASONIC''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 56 Daten-Bits + 1 Stop-Bit
|-
| Daten || 24 Bits (010000000000010000000001) + 16 Adress-Bits + 16 Kommando-Bits
|-
| Start-Bit || 3600µs Puls, 1600µs Pause
|-
| 0-Bit || 565µs Puls, 316µs Pause
|-
| 1-Bit || 565µs Puls, 1140µs Pause
|-
| Stop-Bit || 565µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || LSB first?
|-
|}

==== PENTAX ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''PENTAX''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 6 Daten-Bits + 1 Stop-Bit
|-
| Daten || 6 Kommando-Bits
|-
| Start-Bit || 2200µs Puls, 27100µs Pause
|-
| 0-Bit || 1000µs Puls, 1000µs Pause
|-
| 1-Bit || 1000µs Puls, 3000µs Pause
|-
| Stop-Bit || 1000µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first
|-
|}

==== KATHREIN ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''KATHREIN''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 11 Daten-Bits + 1 Stop-Bit
|-
| Daten || 4 Adress-Bits + 7 Kommando-Bits
|-
| Start-Bit || 210µs Puls, 6218µs Pause
|-
| 0-Bit || 210µs Puls, 1400µs Pause
|-
| 1-Bit || 210µs Puls, 3000µs Pause
|-
| Stop-Bit || 210µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || nach 35ms?
|-
| Bit-Order || MSB first
|-
|}

==== LEGO ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#LEGO Power Functions RC|LEGO]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 16 Daten-Bits + 1 Stop-Bit
|-
| Daten || 16 Kommando-Bits
|-
| Start-Bit || 158µs Puls, 1026µs Pause
|-
| 0-Bit || 158µs Puls, 263µs Pause
|-
| 1-Bit || 158µs Puls, 553µs Pause
|-
| Stop-Bit || 158µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first
|-
|}

==== VINCENT ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#VINCENT|VINCENT]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 32 Daten-Bits + 1 Stop-Bit
|-
| Daten || 16 Adress- und 8 Kommando-Bits + 8 wiederholte Kommando-Bits
|-
| Start-Bit || 2500µs Puls, 4600µs Pause
|-
| 0-Bit || 550µs Puls, 550µs Pause
|-
| 1-Bit || 550µs Puls, 1540µs Pause
|-
| Stop-Bit || 550µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first?
|-
|}

==== THOMSON ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''THOMSON''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 33 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame || 0 Start-Bits + 12 Daten-Bits + 1 Stop-Bit
|-
| Daten || 4 Adress-Bits + 1 Toggle-Bit + 7 Kommando-Bits
|-
| 0-Bit || 550µs Puls, 2000µs Pause
|-
| 1-Bit || 550µs Puls, 4500µs Pause
|-
| Stop-Bit || 550µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || Framewiederholung nach 35ms
|-
| Bit-Order || vermutlich MSB first
|-
|}

==== TELEFUNKEN ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''TELEFUNKEN''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 15 Daten-Bits + 1 Stop-Bit
|-
| Daten || 0 Adress-Bits + 15 Kommando-Bits
|-
| Start-Bit || 600µs Puls, 1500µs Pause
|-
| 0-Bit || 600µs Puls, 600µs Pause
|-
| 1-Bit || 600µs Puls, 1500µs Pause
|-
| Stop-Bit || 600µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || vermutlich MSB first
|-
|}

==== RCCAR ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''RCCAR''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance
|-
| Frame || 1 Start-Bit + 13 Daten-Bits + 1 Stop-Bit
|-
| Daten || 13 Kommando-Bits
|-
| Start-Bit || 2000µs Puls, 2000µs Pause
|-
| 0-Bit || 600µs Puls, 900µs Pause
|-
| 1-Bit || 600µs Puls, 450µs Pause
|-
| Stop-Bit || 600µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || nach 40ms?
|-
| Bit-Order || LSB first
|-
|}

==== RCMM ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#RCMM-Protokoll|RCMM]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz
|-
| Kodierung || Pulse Distance
|-
| Frame RCMM32 || 1 Start-Bit + 32 Daten-Bits + 1 Stop-Bit
|-
| Frame RCMM24 || 1 Start-Bit + 24 Daten-Bits + 1 Stop-Bit
|-
| Frame RCMM12 || 1 Start-Bit + 12 Daten-Bits + 1 Stop-Bit
|-
| Daten RCMM32 || 16 Adress-Bits (= 4 Mode-Bits + 12 Device-Bits) + 1 Toggle-Bit + 15 Kommando-Bits
|-
| Daten RCMM24 || 16 Adress-Bits (= 4 Mode-Bits + 12 Device-Bits) + 1 Toggle-Bit + 7 Kommando-Bits
|-
| Daten RCMM12 || 4 Adress-Bits (= 2 Mode-Bits + 2 Device-Bits) + 8 Kommando-Bits
|-
| Start-Bit || 500µs Puls, 220µs Pause
|-
| 00-Bits || 230µs Puls, 220µs Pause
|-
| 01-Bits || 230µs Puls, 380µs Pause
|-
| 10-Bits || 230µs Puls, 550µs Pause
|-
| 11-Bits || 230µs Puls, 720µs Pause
|-
| Stop-Bit || 230µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || nach 80ms
|-
| Bit-Order || LSB first
|-
|}

=== Pulse Width Protokolle ===
[[Datei:Pulse-Width.png|miniatur|Pulse Width Coding]]
''' '''
''' '''
''' '''
''' '''
''' '''
''' '''

==== SIRCS ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#SIRCS-Protokoll|SIRCS]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
|Frequenz ||40 kHz
|-
| Kodierung || Pulse Width
|-
| Frame || 1 Start-Bit + 12-20 Daten-Bits, kein Stop-Bit
|-
| Daten || 7 Kommando-Bits + 5 Adress-Bits + bis zu 8 zusätzliche Bits
|-
| Start-Bit || 2400µs Puls, 600µs Pause
|-
| 0-Bit || 600µs Puls, 600µs Pause
|-
| 1-Bit || 1200µs Puls, 600µs Pause
|-
| Wiederholung || zweimalig nach ca. 25ms, d.h. 2. und 3. Frame
|-
| Tasten-Wiederholung || ab dem 4. identischen Frame, Abstand ca. 25ms
|-
| Bit-Order || LSB first
|-
|}

=== Pulse Distance Width Protokolle ===
[[Datei:Pulse-Distance-Width.png|miniatur|Pulse Distance Width Coding]]
''' '''
''' '''
''' '''
''' '''
''' '''
''' '''

==== NUBERT ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''NUBERT''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz?
|-
| Kodierung || Pulse Distance Width
|-
| Frame || 1 Start-Bit + 10 Daten-Bits + 1 Stop-Bit
|-
| Daten || 0 Adress-Bits + 10 Kommando-Bits ?
|-
| Start-Bit || 1340µs Puls, 340µs Pause
|-
| 0-Bit || 500µs Puls, 1300µs Pause
|-
| 1-Bit || 1340µs Puls, 340µs Pause
|-
| Stop-Bit || 500µs Puls
|-
| Wiederholung || einmalig nach 35ms
|-
| Tasten-Wiederholung || dritter, fünfter, siebter usw. identischer Frame
|-
| Bit-Order || MSB first?
|-
|}

==== FAN ====

Das Protokoll ist sehr ähnlich zu [[IRMP#NUBERT|NUBERT]], jedoch wird nur ein Frame gesandt. Außerdem werden 11 statt 10 Datenbits verwendet und kein Stop-Bit versandt. Die Pause zwischen Frame-Wiederholungen ist wesentlich geringer.

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''FAN ''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz
|-
| Kodierung || Pulse Distance Width
|-
| Frame || 1 Start-Bit + 11 Daten-Bits + 0 Stop-Bits
|-
| Daten || 0 Adress-Bits + 11 Kommando-Bits
|-
| Start-Bit || 1280µs Puls, 380µs Pause
|-
| 0-Bit || 380µs Puls, 1280µs Pause
|-
| 1-Bit || 1280µs Puls, 380µs Pause
|-
| Stop-Bit || 500µs Puls
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || nach 6,6ms Pause
|-
| Bit-Order || MSB first
|-
|}

==== SPEAKER ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''SPEAKER''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance Width
|-
| Frame || 1 Start-Bit + 10 Daten-Bits + 1 Stop-Bit
|-
| Daten || 0 Adress-Bits + 10 Kommando-Bits ?
|-
| Start-Bit || 440µs Puls, 1250µs Pause
|-
| 0-Bit || 440µs Puls, 1250µs Pause
|-
| 1-Bit || 1250µs Puls, 440µs Pause
|-
| Stop-Bit || 440µs Puls
|-
| Wiederholung || einmalig nach ca. 38ms
|-
| Tasten-Wiederholung || dritter, fünfter, siebter usw. identischer Frame
|-
| Bit-Order || MSB first?
|-
|}

==== ROOMBA ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''ROOMBA''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Distance Width
|-
| Frame || 1 Start-Bit + 7 Daten-Bits + 0 Stop-Bit
|-
| Daten || 0 Adress-Bits + 7 Kommando-Bits
|-
| Start-Bit || 2790µs Puls, 930µs Pause
|-
| 0-Bit || 930µs Puls, 2790µs Pause
|-
| 1-Bit || 2790µs Puls, 930µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || dreimalig nach jeweils 18ms?
|-
| Tasten-Wiederholung || noch unbekannt
|-
| Bit-Order || MSB first
|-
|}

=== Biphase Protokolle ===
[[Datei:Biphase-Coding.png|miniatur|Biphase Coding]]
''' '''
''' '''
''' '''
''' '''
''' '''
''' '''

==== RC5 + RC5X ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#RC5- und RC5x-Protokoll|RC5 + RC5X]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz
|-
| Kodierung || Biphase (Manchester)
|-
| Frame RC5 || 2 Start-Bits + 12 Daten-Bits + 0 Stop-Bits
|-
| Daten RC5 || 1 Toggle-Bit + 5 Adress-Bits + 6 Kommando-Bits
|-
| Frame RC5X || 1 Start-Bit + 13 Daten-Bits + 0 Stop-Bit
|-
| Daten RC5X || 1 invertiertes Kommando-Bit + 1 Toggle-Bit + 5 Adress-Bits + 6 Kommando-Bits
|-
| Start-Bit || 889µs Pause, 889µs Puls
|-
| 0-Bit || 889µs Puls, 889µs Pause
|-
| 1-Bit || 889µs Pause, 889µs Puls
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || MSB first
|-
|}

==== RCII ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''RCII''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 31.25 kHz
|-
| Kodierung || Biphase (Manchester)
|-
| Frame || 1 Pre-Bit + 1 Start-Bit + 9 Daten-Bits + 0 Stop-Bits
|-
| Daten || 0 Adress-Bits + 9 Kommando-Bits
|-
| Pre-Bit || 512µs Puls, 2560µs Pause
|-
| Start-Bit || 1024µs Puls, '''keine Pause'''
|-
| 0-Bit || 512µs Pause, 512µs Puls
|-
| 1-Bit || 512µs Puls, 512µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames nach 118ms
|-
| Bemerkung || Beim Tasten-Loslassen wird ein Frame mit Kommando 111111111 = 0x1FF gesandt
|-
| Bit-Order || MSB first
|-
|}

==== S100 ====

Ähnlich zu RC5x, aber 14 statt 13 Daten-Bits und 56kHz Modulation

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''S100''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 56 kHz
|-
| Kodierung || Biphase (Manchester)
|-
| Frame || 1 Start-Bit + 14 Daten-Bits + 0 Stop-Bit
|-
| Daten || 1 invertiertes Kommando-Bit + 1 Toggle-Bit + 5 Adress-Bits + 7 Kommando-Bits
|-
| Start-Bit || 889µs Pause, 889µs Puls
|-
| 0-Bit || 889µs Puls, 889µs Pause
|-
| 1-Bit || 889µs Pause, 889µs Puls
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || MSB first
|-
|}

==== RC6 + RC6A ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#RC6 und RC6A-Protokoll|RC6 + RC6A]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz
|-
| Kodierung || Biphase (Manchester)
|-
| Frame RC6 || 1 Start-Bit + 1 Bit "1" + 3 Mode-Bits (000) + 1 Toggle-Bit + 16 Daten-Bits + 2666µs pause
|-
| Frame RC6A || 1 Start-Bit + 1 Bit "1" + 3 Mode-Bits (110) + 1 Toggle-Bit + 31 Daten-Bits + 2666µs pause
|-
| Daten RC6 || 8 Adress-Bits + 8 Kommando Bits
|-
| Daten RC6A || "1" + 14 Hersteller-Bits + 8 System-Bits + 8 Kommando-Bits
|-
| Daten RC6A Pace (Sky) || "1" + 3 Mode-Bits ("110") + 1 Toggle-Bit(UNUSED "0") + 16 Bit + 1 Toggle(!) + 15 Kommando-Bits
|-
| Start-Bit || 2666µs Puls, 889µs Pause
|-
| Toggle 0-Bit || 889µs Pause, 889µs Puls
|-
| Toggle 1-Bit || 889µs Puls, 889µs Pause
|-
| 0-Bit || 444µs Pause, 444µs Puls
|-
| 1-Bit || 444µs Puls, 444µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms
|-
| Bit-Order || MSB first
|-
|}

==== GRUNDIG + NOKIA ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#Grundig-Protokoll|GRUNDIG + NOKIA]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz (?)
|-
| Kodierung || Biphase (Manchester)
|-
| Frame-Paket || 1 Start-Frame + 19,968ms Pause + N Info-Frames + 117,76ms Pause + 1 Stop-Frame
|-
| Start-Frame || 1 Pre-Bit + 1 Start-Bit + 9 Daten-Bits (alle 1) + 0 Stop-Bits
|-
| Info-Frame || 1 Pre-Bit + 1 Start-Bit + 9 Daten-Bits + 0 Stop-Bits
|-
| Stop-Frame || 1 Pre-Bit + 1 Start-Bit + 9 Daten-Bits (alle 1) + 0 Stop-Bits
|-
| Daten Grundig || 9 Kommando-Bits + 0 Adress-Bits
|-
| Daten Nokia || 8 Kommando-Bits + 8 Adress-Bits
|-
| Pre-Bit || 528µs Puls, 2639µs Pause
|-
| Start-Bit || 528µs Puls, 528µs Pause
|-
| 0-Bit || 528µs Pause, 528µs Puls
|-
| 1-Bit || 528µs Puls, 528µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Info-Frames mit einem Pausenabstand von 117,76ms
|-
| Bit-Order || LSB first
|-
|}

==== IR60 (SDA2008) ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''[[IRMP#IR60 (SDA2008 bzw. MC14497P)|IR60 (SDA2008)]]''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 30 kHz
|-
| Kodierung || Biphase (Manchester)
|-
| Start Frame || 1 Start-Bit + 101111 + 0 Stop-Bits + 22ms Pause
|-
| Daten Frame || 1 Start-Bit + 7 Daten-Bits + 0 Stop-Bits
|-
| Daten || 0 Adress-Bits + 7 Kommando-Bits
|-
| Start-Bit || 528µs Puls, 2639µs Pause
|-
| 0-Bit || 528µs Pause, 528µs Puls
|-
| 1-Bit || 528µs Puls, 528µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || N-fache Wiederholung des Info-Frames mit einem Pausenabstand von 117,76ms
|-
| Bit-Order || LSB first
|-
|}

==== SIEMENS + RUWIDO ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''SIEMENS + RUWIDO''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 36 kHz? (Merlin-Tastatur mit Ruwido-Protokoll: 56 kHz)
|-
| Kodierung || Biphase (Manchester)
|-
| Frame Siemens || 1 Start-Bit + 22 Daten-Bits + 0 Stop-Bits
|-
| Frame Ruwido || 1 Start-Bit + 17 Daten-Bits + 0 Stop-Bits
|-
| Daten Siemens || 11 Adress-Bits + 10 Kommando-Bits + 1 invertiertes Bit (letztes Bit davor nochmal invertiert)
|-
| Daten Ruwido || 9 Adress-Bits + 7 Kommando-Bits + 1 invertiertes Bit (letztes Bit davor nochmal invertiert)
|-
| Start-Bit || 275µs Puls, 275µs Pause
|-
| 0-Bit || 275µs Pause, 275µs Puls
|-
| 1-Bit || 275µs Puls, 275µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || 1-malige Wiederholung mit gesetztem Repeat-Bit (?)
|-
| Tasten-Wiederholung || N-fache Wiederholung des Original-Frames innerhalb von 100ms (?)
|-
| Bit-Order || MSB first
|-
|}

==== A1TVBOX ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''A1TVBOX''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Biphase (Manchester) asymmetrisch
|-
| Frame || 2 Start-Bits + 16 Daten-Bits + 0 Stop-Bits
|-
| Daten || 8 Adress-Bits + 8 Kommando-Bits
|-
| Start-Bits || "10", also 250µs Puls, 150µs + 150µs Pause, 250µs Puls
|-
| 0-Bit || 150µs Pause, 250µs Puls
|-
| 1-Bit || 250µs Puls, 150µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first
|-
|}

==== MERLIN ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''MERLIN''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 56 kHz
|-
| Kodierung || Biphase (Manchester) asymmetrisch
|-
| Frame || 2 Start-Bits + 18 Daten-Bits + 0 Stop-Bits
|-
| Daten || 8 Adress-Bits + 10 Kommando-Bits
|-
| Start-Bits || "10", also 210µs Puls, 210µs + 210µs Pause, 210µs Puls
|-
| 0-Bit || 210µs Pause, 210µs Puls
|-
| 1-Bit || 210µs Puls, 210µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || unbekannt
|-
| Bit-Order || MSB first
|-
|}

==== ORTEK ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''ORTEK''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Biphase (Manchester) symmetrisch
|-
| Frame || 2 Start-Bits + 18 Daten-Bits + 0 Stop-Bits
|-
| Daten || 6 Adress-Bits + 2 Spezial-Bits + 6 Kommando-Bits + 4 Spezial-Bits
|-
| Start-Bit || 2000µs Puls, 1000µs Pause
|-
| 0-Bit || 500µs Pause, 500µs Puls
|-
| 1-Bit || 500µs Puls, 500µs Pause
|-
| Stop-Bit || kein Stop-Bit
|-
| Wiederholung || 2 zusätzliche Frames mit gesetzten Spezial-Bits
|-
| Tasten-Wiederholung || N-fache Wiederholung des 2. Frames
|-
| Bit-Order || MSB first
|-
|}

=== Pulse Position Protokolle ===

[[Datei:Pulse-Position.png|miniatur|Pulse Position Coding]]
''' '''
''' '''
''' '''
''' '''
''' '''
''' '''

==== NETBOX ====

{| {{Tabelle}}
|- style="background-color:#eeeeee"
! '''NETBOX''' || Wert
|-
|style="width: 15em"|
|style="width: 50em"|
|-
| Frequenz || 38 kHz?
|-
| Kodierung || Pulse Position
|-
| Frame || 1 Start-Bit + 16 Daten-Bits, kein Stop-Bit
|-
| Daten || 3 Adress-Bits + 13 Kommando-Bits
|-
| Start-Bit || 2400µs Puls, 800µs Pause
|-
| Bitlänge || 800µs
|-
| Wiederholung || keine
|-
| Tasten-Wiederholung || Abstand ca. 35ms?
|-
| Bit-Order || LSB first
|-
|}

== Software-Historie IRMP ==

=== Änderungen IRMP in 3.2.x ===

Version 3.2.6:

* 27.01.2021: '''Neues IR-Protokoll:''' [[IRMP#MELINERA|MELINERA]]
* 27.01.2021: Protokoll [[IRMP#LEGO|LEGO]]: Timing verbessert
* 27.01.2021: Protokoll [[IRMP#RUWIDO|RUWIDO]]: Timing verbessert
* 27.01.2021: Protokoll [[IRMP#NEC|NEC]]: Senden von Repetition-Frames ermöglicht

Version 3.2.3:

* 15.08.2020: '''Neues RF-Protokoll:''' [[IRMP#RF_MEDION|RF_MEDION]]

Version 3.2.2:

* 09.07.2020: Zusätzliche Erkennung der Funkkanäle beim RF_X10 Protokoll
* 09.07.2020: Verbesserung der Erkennung von RF-Frames durch neue Stop-Bit-Behandlung.
* 09.07.2020: Verbesserte Detektion von RF_GEN24-Protokollen
* 09.07.2020: '''NEU:''' Detektion, ob/wann eine Fernbedienungstaste losgelassen wird, siehe Kapitel '''[[IRMP#.22Entprellen.22_von_Tasten|Entprellen von Tasten]]'''.

Version 3.2.1:

* 22.06.2020: Mini-Bugfix

Version 3.2.0:

* 22.06.2020: Unterstützung von 433MHz Funkprotokollen (RF)
* 22.06.2020: '''Neues RF-Protokoll:''' [[IRMP#RF_GEN24|RF_GEN24]]
* 22.06.2020: '''Neues RF-Protokoll:''' [[IRMP#RF_X10|RF_X10]]

Ältere Versionen:

* 26.08.2019: '''Neues Protokoll:''' [[IRMP#METZ|METZ]]
* 26.08.2019: '''Neues Protokoll:''' [[IRMP#ONKYO|ONKYO]]
* 10.09.2018: '''Neues Protokoll:''' [[IRMP#RCII|RCII]]
* 06.09.2018: Support für STM32 mit HAL-Library
* 30.08.2018: Neue Option: IRMP_USE_IDLE_CALL
* 29.08.2018: Portierung auf ChibiOS
* 29.08.2018: Neues Protokoll: GREE
* 19.02.2018: Korrektur bei der Behandlung von irmp_flags nach ungültigen IR-Frames
* 25.08.2017: Neues Protokoll: IRMP16 zwecks transparenter Datenübertragung von 16-Bit-Daten
* Neues Protokoll: SAMSUNGAH
* Verbesserte ESP8266-Unterstützung
* 16.12.2016: Unterstützung von Nicht-Standard Nec-Repetition-Frames (4500us Pause statt 2250us)
* 18.11.2016: Buffer Overflow in irmp-main-avr-uart.c korrigiert
* 19.09.2016: Neues Protokoll [[IRMP#VINCENT|VINCENT]]
* 09.09.2016: Neues Protokoll [[IRMP#MITSU_HEAVY|Mitsubishi Heavy (Klimaanlage)]]
* 09.09.2016: Anpassungen an Compiler PIC C18
* 12.01.2016: Korrektur Portierung auf ESP8266
* 12.01.2016: Portierung auf MBED
* 12.01.2016: Mehrere plattformabhängige Beispiel-Main-Dateien hinzugefügt
* 17.11.2015: '''Neues Protokoll''': [[IRMP#PANASONIC|PANASONIC (Beamer)]]
* 17.11.2015: Portierung auf ESP8266
* 17.11.2015: Portierung auf Teensy (3.x)
* 10.11.2015: Unterstützung für STM8 Mikrcontroller
* 20.09.2015: '''Neues Protokoll''': [[IRMP#TECHNICS|TECHNICS]]
* 15.06.2015: '''Neues Protokoll''': [[IRMP#ACP24|ACP24]]
* 29.05.2015: '''Neues Protokoll''': [[IRMP#S100|S100]]
* 29.05.2015: Kleinere Korrekturen
* 28.05.2015: Logging für XMega hinzugefügt
* 28.05.2015: Timing-Korrekturen für FAN-Protokoll
* 27.05.2015: '''Neues Protokoll''': [[IRMP#MERLIN|MERLIN]]
* 27.05.2015: '''Neues Protokoll''': [[IRMP#FAN|FAN]]
* 18.05.2015: F_CPU Macro für STM32L1XX hinzugefügt
* 18.05.2015: Korrekturen zur XMega-Portierung
* 23.04.2015: '''Neues Protokoll''': [[IRMP#PENTAX|PENTAX]]
* 23.04.2015: Portierung auf AVR XMega
* 19.09.2014: Kleineren Bug behoben: Fehlendes Newline vor #else eingefügt
* 18.09.2014: Logging für ARM STM32F10X hinzugefügt
* 17.09.2014: PROGMEM-Zugriff für Array irmp_protocol_names[] korrigiert.
* 15.09.2014: Timing-Toleranzen für [[IRMP#KASEIKYO|KASEIKYO]]-Protokoll vergrößert
* 15.09.2014: Wechsel von irmp_protocol_names auf PROGMEM, zusätzliche UART Routinen in irmp-main-avr-uart.c
* 21.07.2014: Portierung auf PIC 12F1840
* 09.07.2014: '''Neues Protokoll''': [[IRMP#SAMSUNG48|SAMSUNG48]]
* 09.07.2014: Kleine Syntaxfehlerkorrektur
* 01.07.2014: Logging für ARM_STM32F4XX eingebaut
* 01.07.2014: IRMP port für PIC XC8 compiler, Variadic Macros herausgenommen wg. dummen XC8-Compiler :-(
* 05.06.2014: '''Neues Protokoll''': [[IRMP#LGAIR|LGAIR]]
* 30.05.2014: '''Neues Protokoll''': [[IRMP#SPEAKER|SPEAKER]]
* 30.05.2014: Timings für [[IRMP#SAMSUNG|SAMSUNG]]-Protokolle optimiert
* 20.02.2014: Fehlerhaftes Decodieren des [[IRMP#SIEMENS_+_RUWIDO|SIEMENS]]-Protokolls korrigiert
* 19.02.2014: '''Neue Protokolle''': [[IRMP#RCMM|RCMM32, RCMM24 und RCMM12]]
* 17.09.2014: Timing für [[IRMP#ROOMBA|ROOMBA]] verbessert
* 09.04.2013: '''Neues Protokoll''': [[IRMP#ROOMBA|ROOMBA]]
* 09.04.2013: Verbesserte Frame-Erkennung für [[IRMP#ORTEK|ORTEK (Hama)]]
* 19.03.2013: '''Neues Protokoll''': [[IRMP#ORTEK|ORTEK (Hama)]]
* 19.03.2013: '''Neues Protokoll''': [[IRMP#TELEFUNKEN|TELEFUNKEN]]
* 12.03.2013: Geänderte Timing-Toleranzen für [[IRMP#RECS80|RECS80]]- und [[IRMP#RECS80EXT|RECS80EXT]]-Protokoll
* 21.01.2013: Korrekturen Erkennung des Wiederholungsframes beim [[IRMP#DENON|DENON]]-Protokoll
* 17.01.2013: Korrekturen Frame-Erkennung beim [[IRMP#DENON|DENON]]-Protokoll
* 11.12.2012: '''Neues Protokoll''': [[IRMP#A1TVBOX|A1TVBOX]]
* 07.12.2012: Verbesserte Erkennung von [[IRMP#DENON|DENON]]-Wiederholungsframes
* 19.11.2012: Portierung auf Stellaris LM4F120 Launchpad von TI (ARM Cortex M4)
* 06.11.2012: Korrektur [[IRMP#DENON|DENON]]-Frame-Erkennung
* 26.10.2012: Einige Timer-Korrekturen, Anpassungen an Arduino
* 11.07.2012: '''Neues Protokoll''': [[IRMP#BOSE|BOSE]]
* 18.06.2012: Unterstützung für ATtiny87/167 hinzugefügt
* 05.06.2012: Kleinere Korrekturen Portierung auf ARM STM32
* 05.06.2012: Include-Korrektur in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpextlog.c?view=markup irmpextlog.c]
* 05.06.2012: Bugfix, wenn nur [[IRMP#NEC_+_extended_NEC|NEC]] und [[IRMP#NEC42|NEC42]] aktiviert
* 23.05.2012: Portierung auf ARM STM32
* 23.05.2012: Bugfix Frame-Erkennung beim [[IRMP#DENON|DENON]]-Protokoll
* 27.02.2012: Bug in IR60-Decoder behoben
* 27.02.2012: Bug in CRC-Berechnung von [[IRMP#KASEIKYO|KASEIKYO]]-Frames behoben
* 27.02.2012: Portierung auf C18 Compiler für PIC-Mikroprozessoren
* 13.02.2012: Bugfix: oberstes Bit in Adresse falsch bei [[IRMP#NEC_+_extended_NEC|NEC]]-Protokoll, wenn auch [[IRMP#NEC42|NEC42]]-Protokoll eingeschaltet ist.
* 13.02.2012: Timing von [[IRMP#SAMSUNG|SAMSUNG]]- und [[IRMP#SAMSUNG32|SAMSUNG32]]-Protokoll korrigiert
* 13.02.2012: [[IRMP#KASEIKYO|KASEIKYO]]: Genre2-Bits werden nun im oberen Nibble von flags gespeichert.
* 20.09.2011: '''Neues Protokoll''': [[IRMP#KATHREIN|KATHREIN]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#SIEMENS_+_RUWIDO|RUWIDO]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#THOMSON|THOMSON]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#IR60 (SDA2008)|IR60 (SDA2008)]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#LEGO|LEGO]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#NEC16|NEC16]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#NEC42|NEC42]]
* 20.09.2011: '''Neues Protokoll''': [[IRMP#NETBOX|NETBOX]]
* 20.09.2011: Portierung auf ATtiny84 und ATtiny85
* 20.09.2011: Verbesserung von Tastenwiederholungen bei [[IRMP#RC5_+_RC5X|RC5]]
* 20.09.2011: Verbessertes Decodieren von [[IRMP#Biphase|Biphase]]-Protokollen
* 20.09.2011: Korrekturen am [[IRMP#RECS80|RECS80]]-Decoder
* 20.09.2011: Korrekturen beim Erkennen von zusätzlichen Bits im SIRCS-Protocol
* 18.01.2011: Korrekturen für [[IRMP#SIEMENS_+_RUWIDO|SIEMENS]]-Protokoll
* 18.01.2011: '''Neues Protokoll''': [[IRMP#NIKON|NIKON]]
* 18.01.2011: Speichern der zusätzlichen Bits (>12) im [[IRMP#SIRCS|SIRCS]]-Protokoll in der Adresse
* 18.01.2011: Timing-Korrekturen für [[IRMP#DENON|DENON]]-Protokoll
* 04.09.2010: Bugfix für F_INTERRUPTS >= 16000
* 02.09.2010: '''Neues Protokoll''': [[IRMP#RC6_+_RC6A|RC6A]]
* 29.08.2010: '''Neues Protokoll''': [[IRMP#JVC|JVC]]
* 29.08.2010: [[IRMP#KASEIKYO|KASEIKYO]]-Protokoll: Berücksichtigung der Genre-Bits. '''ACHTUNG: dadurch neue Command-Codes!'''
* 29.08.2010: [[IRMP#KASEIKYO|KASEIKYO]]-Protokoll: Verbesserte Behandlung von Wiederholungs-Frames
* 29.08.2010: Verbesserte Unterstützung des [[IRMP#APPLE|APPLE]]-Protokolls. '''ACHTUNG: dadurch neue Adress-Codes!'''
* 01.07.2010: Bugfix: Einführen eines Timeouts für [[IRMP#NEC_+_extended_NEC|NEC]]-Repetition-Frames, um "Geisterkommandos" zu verhindern.
* 26.06.2010: Bugfix: Deaktivieren von [[IRMP#RECS80|RECS80]], [[IRMP#RECS80EXT|RECS80EXT]] & [[IRMP#SIEMENS_+_RUWIDO|SIEMENS]] bei geringer Interrupt-Rate
* 25.06.2010: '''Neues Protokoll''': [[IRMP#RCCAR|RCCAR]]
* 25.06.2010: Tastenerkennung für [[IRMP#FDC|FDC]]-Protokoll (IR-keyboard) erweitert
* 25.06.2010: Interrupt-Frequenz nun bis zu 20kHz möglich
* 09.06.2010: '''Neues Protokoll''': [[IRMP#FDC|FDC]] (IR-keyboard)
* 09.06.2010: Timing für [[IRMP#DENON|DENON]]-Protokoll korrigiert
* 02.06.2010: '''Neues Protokoll''': [[IRMP#SIEMENS_+_RUWIDO|SIEMENS]] (Gigaset)
* 26.05.2010: '''Neues Protokoll''': [[IRMP#GRUNDIG_+_NOKIA|NOKIA]]
* 26.05.2010: Bugfix Auswertung von langen Tastendrücken bei [[IRMP#GRUNDIG_+_NOKIA|GRUNDIG]]-Protokoll
* 17.05.2010: Bugfix [[IRMP#SAMSUNG32|SAMSUNG32]]-Protokoll: Kommando-Bit-Maske korrigiert
* 16.05.2010: '''Neues Protokoll''': [[IRMP#GRUNDIG_+_NOKIA|GRUNDIG]]
* 16.05.2010: Behandlung von automatischen Frame-Wiederholungen beim [[IRMP#SIRCS|SIRCS]]-, [[IRMP#SAMSUNG32|SAMSUNG32]]- und [[IRMP#NUBERT|NUBERT]]-Protokoll verbessert.
* 28.04.2010: Nur einige kosmetische Code-Optimierungen
* 16.04.2010: Sämtliche Timing-Toleranzen angepasst/optimiert
* 12.04.2010: '''Neues Protokoll''': [[IRMP#B&O|Bang & Olufsen]]
* 29.03.2010: Bugfix beim Erkennen von mehrfachen [[IRMP#NEC_+_extended_NEC|NEC]]-Repetition-Frames
* 29.03.2010: Konfiguration in [http://www.mikrocontroller.net/svnbrowser/irmp/irmpconfig.h?view=markup irmpconfig.h] ausgelagert
* 29.03.2010: Einführung einer Programmversion in README.txt: Version 1.0
* 17.03.2010: '''Neues Protokoll''': [[IRMP#NUBERT|NUBERT]]
* 16.03.2010: Korrektur der RECS80-Startbit-Timings
* 16.03.2010: '''Neues Protokoll''': [[IRMP#RECS80EXT|RECS80 Extended]]
* 15.03.2010: Codeoptimierung
* 14.03.2010: Portierung auf PIC
* 11.03.2010: Anpassungen an verschiedene ATMega-Typen durchgeführt
* 07.03.2010: Bugfix: Zurücksetzen der Statemachine nach einem unvollständigen [[IRMP#RC5_+_RC5X|RC5]]-Frame
* 05.03.2010: '''Neues Protokoll''': [[IRMP#APPLE|APPLE]]
* 05.03.2010: Die Daten irmp_data.addr + irmp_data.command werden nun in der jeweiligen Bit-Order des verwendeten Protokolls gespeichert
* 04.03.2010: '''Neues Protokoll''': [[IRMP#SAMSUNG32|SAMSUNG32]] (Mix aus [[IRMP#SAMSUNG|SAMSUNG]] & [[IRMP#NEC_+_extended_NEC|NEC]]-Protokoll)
* 04.03.2010: Änderung der [[IRMP#SIRCS|SIRCS]]- und [[IRMP#KASEIKYO|KASEIKYO]]-Toleranzen
* 02.03.2010: [[IRMP#SIRCS|SIRCS]]: Korrekte Erkennung und Unterdrückung von automatischen Frame-Wiederholungen
* 02.03.2010: [[IRMP#SIRCS|SIRCS]]: Device-ID-Bits werden nun in irmp_data.command und nicht mehr in irmp_data.address gespeichert
* 02.03.2010: Vergrößerung des Scan Buffers (zwecks Protokollierung)
* 24.02.2010: Neue Variable flags in IRMP_DATA zur Erkennung von langen Tastendrücken
* 20.02.2010: Bugfix [[IRMP#DENON|DENON]]-Protokoll: Wiederholungsframe grundsätzlich invertiert
* 19.02.2010: Erkennung von [[IRMP#NEC_+_extended_NEC|NEC]]-Protokoll-Varianten, z. B. [[IRMP#APPLE|APPLE]]-Fernbedienung
* 19.02.2010: Erkennung von [[IRMP#RC6_+_RC6A|RC6]]- und [[IRMP#DENON|DENON]]-Protokoll
* 19.02.2010: Verbesserung des [[IRMP#RC5_+_RC5X|RC5]]-Decoders (Bugfixes)
* 13.02.2010: Bugfix: Puls/Pausen-Counter um 1 zu niedrig, nun bessere Erkennung bei Protokollen mit sehr kurzen Pulszeiten
* 13.02.2010: Erkennung der [[IRMP#NEC_+_extended_NEC|NEC]]-Wiederholungssequenz
* 12.02.2010: [[IRMP#RC5_+_RC5X|RC5]]-Protokoll-Decoder hinzugefügt
* 05.02.2010: Konflikt zwischen [[IRMP#SAMSUNG|SAMSUNG]]- und [[IRMP#MATSUSHITA|MATSUSHITA]]-Protokoll beseitigt
* 07.01.2010: Erste Version

== Literatur ==

=== IR-Übersicht ===

* http://www.sbprojects.net/knowledge/ir/index.php
* http://www.epanorama.net/links/irremote.html
* http://www.elektor.de/jahrgang/2008/juni/cc2-avr-projekt-%283%29-unsichtbare-kommandos.497184.lynkx?tab=4 (IR Übersicht & RC5)
* http://mc.mikrocontroller.com/de/IR-Protokolle.php

=== SIRCS-Protokoll ===

* http://www.sbprojects.net/knowledge/ir/sirc.php
* http://mc.mikrocontroller.com/de/IR-Protokolle.php#SIRCS
* http://www.ustr.net/infrared/sony.shtml
* http://users.telenet.be/davshomepage/sony.htm
* http://picprojects.org.uk/projects/sirc/
* http://www.celadon.com/infrared_protocol/infrared_protocols_samples.pdf

=== NEC-Protokoll ===

* http://www.sbprojects.net/knowledge/ir/nec.php
* http://www.ustr.net/infrared/nec.shtml
* http://www.celadon.com/infrared_protocol/infrared_protocols_samples.pdf

=== ACP24-Protokoll ===

Das ACP24-Protokoll wird von Stiebel-Eltron-Klimaanlagen verwendet.

Die 70 Datenbits sind folgendermaßen aufgebaut:

1 2 3 4 5 6
0123456789012345678901234567890123456789012345678901234567890123456789
N VVMMM ? ??? t vmA x y TTTT
0011001000000111000010001010000000000000000010000000000000000000001111on, temp=30

Diese werden in die folgenden 16 Bits von irmp_data.command gewandelt:

5432109876543210
NAVVvMMMmtxyTTTT

Bedeutung der Symbole:

TTTT = Temperatur + 15 Grad
TTTT
----------
0000 ???
0001 ???
0010 ???
0011 18 Grad
0100 19 Grad
0101 20 Grad
0110 21 Grad
...
1111 30 Grad

N = Nacht-Modus
N
----------
0 aus
1 ein

VV = Luefter-Stufe, v muss 1 sein!
VV v
----------
00 1 Stufe 1
01 1 Stufe 2
10 1 Stufe 3
11 1 Automatik

MMM = Modus
MMM m
----------
000 0 Ausschalten
001 0 Einschalten
001 1 Kuehlen
010 1 Lueften
011 1 Entfeuchten
100 1 ???
101 1 ---
110 1 ---
111 1 ---

A = Automatik-Programm
A
----------
0 aus
1 ein

t = Timer
t x y
----------
1 1 0 Timer 1
1 0 1 Timer 2

Um die Klimaanlage mittels [[IRSND]] anzusteuern, kann man folgende Funktionen verwenden:

<syntaxhighlight lang="c">
#include "irmp.h"
#include "irsnd.h"

#define IRMP_ACP24_TEMPERATURE_MASK 0x000F // TTTT

#define IRMP_ACP24_SET_TIMER_MASK (1<<6) // t
#define IRMP_ACP24_TIMER1_MASK (1<<5) // x
#define IRMP_ACP24_TIMER2_MASK (1<<4) // y

#define IRMP_ACP24_SET_MODE_MASK (1<<7) // m
#define IRMP_ACP24_MODE_POWER_ON_MASK (1<<8) // MMMm = 0010 Einschalten
#define IRMP_ACP24_MODE_COOLING_MASK (IRMP_ACP24_SET_MODE_MASK | (1<<8)) // MMMm = 0011 Kuehlen
#define IRMP_ACP24_MODE_VENTING_MASK (IRMP_ACP24_SET_MODE_MASK | (1<<9)) // MMMm = 0101 Lueften
#define IRMP_ACP24_MODE_DEMISTING_MASK (IRMP_ACP24_SET_MODE_MASK | (1<<10) | (1<<8)) // MMMm = 1001 Entfeuchten

#define IRMP_ACP24_SET_FAN_STEP_MASK (1<<11) // v
#define IRMP_ACP24_FAN_STEP_MASK 0x3000 // VV
#define IRMP24_ACP_FAN_STEP_BIT 12 // VV
#define IRMP_ACP24_AUTOMATIC_MASK (1<<14) // A
#define IRMP_ACP24_NIGHT_MASK (1<<15) // N

// possible values for acp24_set_mode();
#define ACP24_MODE_COOLING 1
#define ACP24_MODE_VENTING 2
#define ACP24_MODE_DEMISTING 3

static uint8_t temperature = 18; // 18 degrees

static void
acp24_send (uint16_t cmd)
{
IRMP_DATA irmp_data;

cmd |= (temperature - 15) & IRMP_ACP24_TEMPERATURE_MASK;

irmp_data.protocol = IRMP_ACP24_PROTOCOL;
irmp_data.address = 0x0000;
irmp_data.command = cmd;
irmp_data.flags = 0;

irsnd_send_data (&irmp_data, 1);
}

void
acp24_set_temperature (uint8_t temp)
{
uint16_t cmd = IRMP_ACP24_MODE_POWER_ON_MASK;

temperature = temp;
acp24_send (cmd);
}

void
acp24_off (void)
{
uint16_t cmd = 0;
acp24_send (cmd);
}

#define ACP_FAN_STEP1 0
#define ACP_FAN_STEP2 1
#define ACP_FAN_STEP3 2
#define ACP_FAN_AUTOMATIC 3

void
acp24_fan (uint8_t fan_step)
{
uint16_t cmd = IRMP_ACP24_MODE_POWER_ON_MASK;

cmd |= IRMP_ACP24_SET_FAN_STEP_MASK | ((fan_step << IRMP24_ACP_FAN_STEP_BIT) & IRMP_ACP24_FAN_STEP_MASK);

acp24_send (cmd);
}

void
acp24_set_mode (uint8_t mode)
{
uint16_t cmd = 0;

switch (mode)
{
case ACP24_MODE_COOLING: cmd = IRMP_ACP24_MODE_COOLING_MASK; break;
case ACP24_MODE_VENTING: cmd = IRMP_ACP24_MODE_VENTING_MASK; break;
case ACP24_MODE_DEMISTING: cmd = IRMP_ACP24_MODE_DEMISTING_MASK; break;
default: return;
}
acp24_send (cmd);
}

void
acp24_program_automatic (void)
{
uint16_t cmd = IRMP_ACP24_MODE_POWER_ON_MASK | IRMP_ACP24_AUTOMATIC_MASK;
acp24_send (cmd);
}

void
acp24_program_night (void)
{
uint16_t cmd = IRMP_ACP24_MODE_POWER_ON_MASK | IRMP_ACP24_NIGHT_MASK;
acp24_send (cmd);
}
</syntaxhighlight>

=== LGAIR-Protokoll ===

Der LG Air Conditioner ist eine Klimaanlage, die durch eine "intelligente" Fernbedienung gesteuert wird.
Dies sind die "entschlüsselten" Daten:

<code>
Befehl AAAAAAAA PW Z S T mmm tttt vvvv PPPP
--------------------------------------------------------------------
ON 23C 10001000 00 0 0 0 000 1000 0100 1100
ON 26C 10001000 00 0 0 0 000 1011 0100 1111

OFF 10001000 11 0 0 0 000 0000 0101 0001
TURN OFF 10001000 11 0 0 0 000 0000 0101 0001 (18C currently, identical with off)

TEMP DOWN 23C 10001000 00 0 0 1 000 1000 0100 0100
MODE (to mode0, 23C) 10001000 00 0 0 1 000 1000 0100 0100

TEMP UP (24C) 10001000 00 0 0 1 000 1001 0100 0101
TEMP DOWN 24C 10001000 00 0 0 1 000 1001 0100 0101

TEMP UP (25C) 10001000 00 0 0 1 000 1010 0100 0110
TEMP DOWN 25C 10001000 00 0 0 1 000 1010 0100 0110

TEMP UP (26C) 10001000 00 0 0 1 000 1011 0100 0111

MODE 10001000 00 0 0 1 011 0111 0100 0110 (to mode1, 22C - when switching to mode1 temp automaticall sets to 22C)
ON (mode1, 22C) 10001000 00 0 0 0 011 0111 0100 1110

MODE 10001000 00 0 0 1 001 1000 0100 0101 (to mode2, no temperature displayed)
ON (mode2) 10001000 00 0 0 0 001 1000 0100 1101
MODE (to mode3, 23C) 10001000 00 0 0 1 100 1000 0100 1000
ON (mode3, 23C) 10001000 00 0 0 0 100 1000 0100 0000

VENTILATION SLOW 10001000 00 0 0 1 000 0011 0000 1011
VENTILATION MEDIUM 10001000 00 0 0 1 000 0011 0010 1101
VENTILATION HIGH 10001000 00 0 0 1 000 0011 0100 1111
VENTILATION LIGHT 10001000 00 0 0 1 000 0011 0101 0000

SWING ON/OFF 10001000 00 0 1 0 000 0000 0000 0001

Format: 1 start bit + 8 address bits + 16 data bits + 4 checksum bits + 1 stop bit

Address: AAAAAAAA = 0x88 (8 bits)

Data: PW Z S T MMM tttt vvvv PPPP (16 bits)

PW: Power: 00 = On, 11 = Off

Z: N/A: Always 0

S: Swing: 1 = Toggle swing, all other data bits are zeros.

T: Temp/Vent: 1 = Set temperature and ventilation

MMM: Mode, can be combined with temperature
000=Mode 0
001=Mode 2
010=????
011=Mode 1
100=Mode 3
101=???
111=???

tttt: Temperature:
0000=used by OFF command
0001=????
0010=????
0011=18°C
0100=19°C
0101=20°C
0110=21°C
0111=22°C
1000=23°C
1001=24°C
1010=25°C
1011=26°C
1011=27°C
1100=28°C
1101=29°C
1111=30°C

vvvv: Ventilation:
0000=slow
0010=medium
0011=????
0100=high
0101=light
0110=????
0111=????
...
1111=????

Checksum: PPPP = (DataNibble1 + DataNibble2 + DataNibble3 + DataNibble4) & 0x0F
</code>

=== NEC16-Protokoll (JVC) ===

* http://www.sbprojects.net/knowledge/ir/jvc.php
* http://www.ustr.net/infrared/jvc.shtml

=== SAMSUNG-Protokoll ===

(wurde aus diversen Protokollen (Daewoo u.ä.) zusammengereimt, daher kein direkter Link auf irgendwelche SAMSUNG-Dokumentation verfügbar)

Hier ein Link zum Daewoo-Protokoll, welches dasselbe Prinzip des Sync-Bits in der Mitte eines Frames nutzt, jedoch mit anderen Timing-Werten arbeitet:

* http://users.telenet.be/davshomepage/daewoo.htm

=== MATSUHITA-Protokoll ===

* http://www.celadon.com/infrared_protocol/infrared_protocols_samples.pdf

=== KASEIKYO-Protokoll (auch "Japan-Protokoll") ===

* http://www.mikrocontroller.net/attachment/4246/IR-Protokolle_Diplomarbeit.pdf
* http://www.roboternetz.de/phpBB2/files/entwicklung_und_realisierung_einer_universalinfrarotfernbedienung_mit_timerfunktionen.pdf

=== RECS80- und RECS80-Extended-Protokoll ===

* http://www.sbprojects.net/knowledge/ir/recs80.php

=== RC5- und RC5x-Protokoll ===

* http://www.sbprojects.net/knowledge/ir/rc5.php
* http://mc.mikrocontroller.com/de/IR-Protokolle.php#RC5
* http://users.telenet.be/davshomepage/rc5.htm
* http://www.celadon.com/infrared_protocol/infrared_protocols_samples.pdf
* http://www.opendcc.de/info/rc5/rc5.html

=== Denon-Protokoll ===

* http://mc.mikrocontroller.com/de/IR-Protokolle.php#DENON
* http://www.manualowl.com/m/Denon/AVR-3803/Manual/170243
* http://www.remotecentral.com/cgi-bin/mboard/rc-prontong/thread.cgi?1402

=== RC6 und RC6A-Protokoll ===

* https://www.sbprojects.net/knowledge/ir/rc6.php
* http://www.picbasic.nl/info_rc6_uk.htm

=== Bang & Olufsen ===

* http://www.mikrocontroller.net/attachment/33137/datalink.pdf

=== Grundig-Protokoll ===

* http://www.see-solutions.de/sonstiges/Grundig_10bit.pdf

=== Nokia-Protokoll ===

* http://www.sbprojects.net/knowledge/ir/nrc17.php

=== IR60 (SDA2008 bzw. MC14497P) ===

* http://www.datasheetcatalog.org/datasheet/motorola/MC14497P.pdf

=== LEGO Power Functions RC ===

* http://www.philohome.com/pf/LEGO_Power_Functions_RC_v110.pdf
* http://www.philohome.com/pf/LEGO_Power_Functions_RC_v120.pdf

=== RCMM-Protokoll ===

* http://www.sbprojects.net/knowledge/ir/rcmm.php

=== Diverse Protokolle ===

* http://www.mikrocontroller.net/attachment/4246/IR-Protokolle_Diplomarbeit.pdf
* http://www.celadon.com/infrared_protocol/infrared_protocols_samples.pdf
* http://www.roboternetz.de/phpBB2/files/entwicklung_und_realisierung_einer_universalinfrarotfernbedienung_mit_timerfunktionen.pdf

== IRMP auf Youtube ==

Einige Videos zu [[IRMP#top|IRMP]] habe ich auf Youtube gefunden:

* IRMP. AVR (atmega8, avr-gcc) IR decoder. http://www.youtube.com/watch?v=Q7DJvLIyTEI

* Room-fillig powerful 100W RGB LED mood light - Raumfüllendes Stimmungslicht http://www.youtube.com/watch?v=W4tI2axR3-w

* ir steckdose mit teachin http://www.youtube.com/watch?v=SRs98dIe2WE

* RGB-LED mit iR Fernbedienung und Atmega8 / irmp steuern https://www.youtube.com/watch?v=Lf1Z318NKic

== Weitere Artikel zu IRMP ==

[http://www.infineon.com/dgdl/RF2ir+WhitePaper+V1.0.pdf?folderId=db3a3043191a246301192dd3ee2c2ae4&fileId=db3a30432b57a660012b5c16272c2e81 Whitepaper von Martin Gotschlich, Infineon Technologies AG]

== Hardware / IRMP-Projekte ==

=== Remote IRMP ===

Netzwerkfähiger Infrarot-Sender und Empfänger mit Android Handy als Fernbedienung:

* http://www.mikrocontroller.net/articles/Remote_IRMP

=== USB IR Remote Receiver ===

USB IR Remote Receiver von Hugo Portisch:
* http://www.mikrocontroller.net/articles/USB_IR_Remote_Receiver

=== USB IR Empfänger/Sender/Einschalter mit Wakeup-Timer ===

* http://www.vdr-portal.de/board18-vdr-hardware/board13-fernbedienungen/123572-fertig-irmp-auf-stm32-ein-usb-ir-empf%C3%A4nger-sender-einschalter-mit-wakeup-timer/

* http://www.mikrocontroller.net/articles/IRMP_auf_STM32_-_ein_USB_IR_Empf%C3%A4nger/Sender/Einschalter_mit_Wakeup-Timer

=== USBASP ===

IR-Einschalter auf Grundlage des USBasp
* http://wiki.easy-vdr.de/index.php?title=USBASP_Einschalter

=== Servo-gesteuerter IR-Sender ===

Servo-gesteuerter IR-Sender mit Anlernfunktion von Stefan Pendsa:
* http://forum.mikrokopter.de/topic-21060.html
* [http://svn.mikrokopter.de/listing.php?repname=Projects&path=%2FServo-Controlled+IR-Transmitter%2F&#Ad2417800d6aa14bf08c571a896e9def7 SVN]

=== Lernfähige IR-Fernbedienung ===

Lernfähige IR-Fernbedienung von Robert und Frank M.
* http://www.mikrocontroller.net/articles/DIY_Lernfähige_Fernbedienung_mit_IRMP

=== AVR Moodlight ===

AVR Moodlight von Axel Schwenke
* http://www.mikrocontroller.net/topic/244768

RGB Moodlight mit STM8 von Axel Schwenke
* https://www.mikrocontroller.net/topic/380098

=== Infinity-Mirror-LED-Deckenlampe ===

Infinity-Mirror-LED-Deckenlampe mit Fernbedienung von Philipp Meißner
* http://digital-nw.de/Infinity-Mirror.htm

=== Kinosteuerung ===

Kinosteuerung von Owagner
* http://ccc.zerties.org/index.php/Benutzer:Owagner

=== Phasenanschnittsdimmer ===

Phasenanschnittsdimmer - steuerbar über IR-Fernbedienung:

* http://flosserver.dyndns.org/phasenanschnittsdimmer.php

=== IRDioder – Ikea Dioder Hack ===

Ikea Dioder Hack mit Atmel und Infrarotempfaenger:

* http://marco-difeo.de/tag/infrared/

=== Expedit Coffee Bar ===

Ikea Expedit Regal - umgebaut zur Kaffee-Bar:

* http://chaozlabs.blogspot.de/2013/09/expedit-coffee-bar.html

=== Arduino als IR-Empfänger ===

Arduino als IR-Empfänger:

* http://www.vdr-portal.de/board18-vdr-hardware/board13-fernbedienungen/110918-arduino-als-ir-empf%C3%A4nger-einsetzen/

Weitere Beispiele aus der Arduino Library:

* https://github.com/ukw100/IRMP/tree/master/examples

=== IR-Lautstärkesteuerung mit Stellaris Launchpad ===

IR-Lautstärkesteuerung mit Stellaris Launchpad (ARM Cortex-M4F):

* http://www.anthonyvh.com/2013/03/31/ir-volume-control/

=== RemotePi Board ===

Herunterfahren eines RaspPI mittels Fernbedienung:

* http://www.msldigital.com/pages/more-information

=== Ethernut & IRMP ===

IRMP unter dem RTOS Ethernut:

* http://www.klkl.de/ethernut.html

=== LED strip Remote Control ===

LED-Beleuchtung per Fernbedienung steuern:

* http://www.solderlab.de/index.php/misc/led-strip-remote-control

=== ADAT Audio Mixer ===

Audio Mixer:

* http://mailtonne.de/adat-audio-mixer/

=== Ethersex & IRMP ===

IRMP + IRSND Modul in Ethersex, einer modularen Firmware für AVR MCUs

* http://ethersex.de/index.php/IRMP

=== Mastermind Solver ===

Mastermind-Solver mit LED-Streifen und IR-Fernbedienung

* http://www.mystrobl.de/Plone/basteleien/weitere-bulls-and-cows-mastermind-implementationen/mm-v1821/mastermind-solver-mit-led-streifen-und-ir-fernbedienung

=== A MythTV Remote Control without LIRC ===

PC Remote Control mit ATtiny85

* http://tomscircuits.blogspot.de/2014/12/a-mythtv-remote-control-without-lirc.html

=== IRMP2Keyboard infrared remote to PS2/USB keyboard converter ===

IRMP2Keyboard infrared remote to PS2/USB keyboard converter

https://github.com/M-Reimer/irmp2keyboard

=== IRMP + IRSND Library für STM32F4 ===

IRMP für STM32F4

* http://mikrocontroller.bplaced.net/wordpress/?page_id=1516

IRSND für STM32F4

* http://mikrocontroller.bplaced.net/wordpress/?page_id=1940

=== IRMP auf STM32 - Bauanleitung ===

* http://www.mikrocontroller.net/articles/IRMP_auf_STM32_-_Bauanleitung

=== Studienarbeit - Erweiterung der Arduino Plattform ===

* http://www.eislab.fim.uni-passau.de/files/publications/2010/StudentDiener_ErweiterungDerArduinoPlattform.pdf

=== Forumsbeiträge ===

* [https://www.mikrocontroller.net/topic/444061 Forumsbeitrag]: IRMP und IRSND als Protokoll für 433 MHz Sender/Empfänger funktioniert nicht so ganz
* [https://www.mikrocontroller.net/topic/441010#5248149 Forumsbeitrag]: Frage zu IR-Remote+LED-Strips an AVR

== Danksagung ==

Ganz herzlich bedanken möchte ich mich bei Vlad Tepesch, Klaus Leidinger und Peter K., die mich mit Scan-Dateien ihrer Infrarot-Fernbedienungen versorgt haben. Dank auch an Klaus für seine nächtelangen Tests von [[IRMP#top|IRMP]] & [[IRSND#top|IRSND]].

Ebenso bedanken möchte ich mich bei Christian F. für seine Tipps zur PIC-Portierung. Vielen Dank auch an gera für die Portierung auf den PIC-C18 Compiler. Für die Portierung auf ARM STM32 bedanke ich mich herzlich bei kichi (Michael K.). Vielen Dank auch an Markus Schuster für die Portierung auf Stellaris LM4F120 Launchpad von TI (ARM Cortex M4). Danke an Matthias Frank für die Portierung auf XMega. Vielen Dank auch an Wolfgang S. für die Portierung auf ESP8266, Achill Hasler für die Portierung auf Teensy. Und zuletzt noch Dank an Axel Schwenke für den Port auf STM8.

Mein Dank geht auch an Dániel Körmendi, welcher mich nicht nur immer wieder fleißig mit Scans versorgt, sondern auch das LG-AIR-Protokoll in den [[IRSND]] eingebaut hat. Danke auch hier an Ulrich v.d. Kammer für die [[IRSND]]-Variante des Pentax-Protokolls.

Als letztes möchte ich mich bedanken bei Jojo S., der den größten Teil dieser Dokumentation ins Englische übersetzt hat. Great Job, Jojo!

== Diskussion ==

Meinungen, Verbesserungsvorschläge, harsche Kritik und ähnliches kann im [http://www.mikrocontroller.net/topic/162119 Beitrag: Infrared Multi Protocol Decoder] geäussert werden.

Viel Spaß mit IRMP!

[[Kategorie:Infrarot]]
[[Kategorie:AVR-Projekte]]

Forum-Erweiterungen

2019-11-24T13:15:25Z

Kichi:

Um das Erscheinungsbild von mikrocontroller.net im Browser an die eigenen Bedürfnisse anzupassen, gibt es folgende Möglichkeiten:

* [https://www.userchrome.org/ userChrome.css] oder Client-Side [https://de.wikipedia.org/wiki/JavaScript JavaScript] nur für [https://www.mozilla.org/de/firefox/ Firefox] direkt, bei Chrome ist ein Add-On nötig.<ref>[https://superuser.com/questions/52967/change-default-css-of-google-chrome#191170 SuperUser.com change default css of Google Chrome]</ref>
* [https://www.squarefree.com/bookmarklets/ Bookmarklets]
* Browser-Erweiterung:
** [https://www.greasespot.net GreaseMonkey] Add-On für Firefox
** [https://tampermonkey.net TamperMonkey] Add-On für Firefox, Chrome, Opera Next, Edge, Safari
** [https://violentmonkey.github.io/get-it/ ViolentMonkey] Add-On für Firefox, Chrome, Opera
* Automatischen Import als Extension in [https://de.wikipedia.org/wiki/Google_Chrome Google Chrome] oder [https://de.wikipedia.org/wiki/Vivaldi_(Browser) Vivaldi]

== Threads im Forum ==
* [https://www.mikrocontroller.net/topic/176190 Sonderzeichen für µC.net Posting-Editor]
* [https://www.mikrocontroller.net/topic/200578 Übersicht über alle Dateianhänge in einem Thread]
* [https://www.mikrocontroller.net/topic/219612 JavaScript: Suchfeld in der mikrocontroller.net Titelleiste]
* [https://www.mikrocontroller.net/topic/219625 mikrocontroller.net: statisches Menü]
* [https://www.mikrocontroller.net/topic/261114#2723233 Farbmarkierungen]
** Einfärben Beiträge nach Alter
** Farbmarkierung eigene Beiträge
** Farbmarkierung Beitrgäge, in denen eigener Name vorkommt
** Farbmarkierung TO (funktioniert nicht bei mehrseitigen Threads)
** Farbmarkierung VIP (zB Andreas)
* Wo wurden die Beiträge zitiert? [https://www.mikrocontroller.net/topic/423933#5477508 Umgekehrte Beitragsreferenzen] ([https://www.mikrocontroller.net/topic/423933#6050083 für Greasemonkey])
* [https://www.mikrocontroller.net/topic/414770#4836572 Beiträge eines Benutzers farblich hervorheben] ([https://www.mikrocontroller.net/topic/414770#6050425 für Greasemonkey])



== Weblinks ==
<references/>

[[Kategorie:Forum]]

Forum-Erweiterungen

2019-11-24T13:12:07Z

Kichi:

Um das Erscheinungsbild von mikrocontroller.net im Browser an die eigenen Bedürfnisse anzupassen, gibt es folgende Möglichkeiten:

* [https://www.userchrome.org/ userChrome.css] oder Client-Side [https://de.wikipedia.org/wiki/JavaScript JavaScript] nur für [https://www.mozilla.org/de/firefox/ Firefox] direkt, bei Chrome ist ein Add-On nötig.<ref>[https://superuser.com/questions/52967/change-default-css-of-google-chrome#191170 SuperUser.com change default css of Google Chrome]</ref>
* [https://www.squarefree.com/bookmarklets/ Bookmarklets]
* Browser-Erweiterung:
** [https://www.greasespot.net GreaseMonkey] Add-On für Firefox
** [https://tampermonkey.net TamperMonkey] Add-On für Firefox, Chrome, Opera Next, Edge, Safari
** [https://violentmonkey.github.io/get-it/ ViolentMonkey] Add-On für Firefox, Chrome, Opera
* Automatischen Import als Extension in [https://de.wikipedia.org/wiki/Google_Chrome Google Chrome] oder [https://de.wikipedia.org/wiki/Vivaldi_(Browser) Vivaldi]

== Threads im Forum ==
* [https://www.mikrocontroller.net/topic/176190 Sonderzeichen für µC.net Posting-Editor]
* [https://www.mikrocontroller.net/topic/200578 Übersicht über alle Dateianhänge in einem Thread]
* [https://www.mikrocontroller.net/topic/219612 JavaScript: Suchfeld in der mikrocontroller.net Titelleiste]
* [https://www.mikrocontroller.net/topic/219625 mikrocontroller.net: statisches Menü]
* [https://www.mikrocontroller.net/topic/261114#2723233 Farbmarkierungen]
** Einfärben Beiträge nach Alter
** Farbmarkierung eigene Beiträge
** Farbmarkierung Beitrgäge, in denen eigener Name vorkommt
** Farbmarkierung TO (funktioniert nicht bei mehrseitigen Threads)
** Farbmarkierung VIP (zB Andreas)
* Wo wurden die Beiträge zitiert? [https://www.mikrocontroller.net/topic/423933#5477508 Umgekehrte Beitragsreferenzen] ([https://www.mikrocontroller.net/topic/414770#6050425 für Greasemonkey])
* [https://www.mikrocontroller.net/topic/414770#4836572 Beiträge eines Benutzers farblich hervorheben] ([https://www.mikrocontroller.net/topic/414770#6050425 für Greasemonkey])



== Weblinks ==
<references/>

[[Kategorie:Forum]]

STM32 für Einsteiger

2017-06-30T06:33:54Z

Kichi:

Immer wiederkehrend hier im Forum "Mit welchem Mikrocontroller anfangen?". Es gibt eine große Auswahl und eben so viele Empfehlungen. In diesem Artikel soll zu erst geholfen werden ob ein Cortex-M3/M4 Kern überhaupt der Richtige für den Start ist.
Nicht für jeden ist der [[Cortex]] zu empfehlen, denn die Anforderungen und Wünsche die man realisieren möchte, sowie die eigenen Fähigkeiten sind verschieden.

Es werden meist die Prozessoren [[AVR]], [[PIC]], [[Arduino]], [[MSP430]], [[LPC1xxx]] und [[STM32]] empfohlen. Seltener auch 8051 und M16C. Alle haben Vorzüge und ebenso auch Nachteile.

[[Bild:STM32F407SB.jpg|thumb|right|340px|STM32F417 auf einem Selbstbau-Board]]

= Eigene Fähigkeiten und Wünsche =

Dieser Artikel geht davon aus, dass bereits Elektronikkenntnisse vorhanden sind. Wenn nicht dann sollte man erst einmal den Artikel "[[Absolute Beginner]]" durcharbeiten, sowie die anderen Artikel aus der Kategorie "[http://www.mikrocontroller.net/articles/Kategorie:Grundlagen Grundlagen]".
 Weitere Artikel die andere Prozessoren näher darstellen da sich dieser Artikel hauptsächlich auf [[STM32]] konzentriert: [[Entscheidung Mikrocontroller]] und [[Mikrocontroller Vergleich]]. Die Seiten [[AVR]], [[MSP430]], [[LPC1xxx]] und [[PIC]] zeigen mehr Details über diese µC. Hier werden nur grob ein paar Tabelle zum Vergleichen gezeigt.

Zu erst einmal die Randbedingungen, mit der man sich selbst zu erst einmal einschätzen sollte:
{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Fähigkeit || [[Cortex]] || [[AVR]] || [[Arduino]] || colspan="3" | [[PIC]] || [[MSP430]]
|-
| Bitbreite, jedoch unwichtig für Einsteiger || align="center" | 32-bit || colspan="2" align="center" | 8-bit || align="center" | 8-bit (PIC18) || align="center" | 16-bit (PIC24) || align="center" | 32-bit (PIC32) || align="center" | 16-bit
|-
| Neueinsteiger, kaum Elektronikkenntnisse, noch nie programmiert
| align="center" | O
| align="center" | O <ref name="AVR_TUT1">[http://www.rn-wissen.de/index.php/AVR-Einstieg_leicht_gemacht], RoboterNetz: AVR-Einstieg leicht gemacht</ref><ref name="AVR_TUT2">[http://www.avr-asm-tutorial.net/avr_de/], Tutorial für das Erlernen der Assemblersprache von AVR-Einchip-Prozessoren</ref>
| align="center" | X
| colspan="3" align="center" | O
| align="center" | O
|-
| Wunsch ist SD-Card oder Grafik-Display
| align="center" | X
| colspan="2" align="center" | O
| align="center" | O <ref name="PIC_SD">[http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en537999], Microchip Memory Disk Drive File System for PIC18 PIC24 dsPIC PIC32</ref> || align="center" | X<ref name="PIC_SD" /><ref name="PIC_LCD">[http://www.microchip.com/pagehandler/en-us/technology/graphics/], Microchip Graphics Library</ref> || align="center" | X<ref name="PIC_SD" /><ref name="PIC_LCD" />
| align="center" | X
|-
| Wunsch ist TCP/IP Netzwerk
| align="center" | X
| colspan="2" align="center" | O
| colspan="3" align="center" | X <ref name="PIC_TCP">[http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2505&param=en535724], Microchip TCP/IP stack</ref>
| align="center" | O
|-
|-
| Wunsch ist Kamera und Video-/Bildbearbeitung
| align="center" | X
| colspan="2" align="center" | -
| align="center" | - || align="center" | - || align="center" | X
| align="center" | -
|-
| Möchte die Erkenntnisse beruflich nutzen
| align="center" | X
| align="center" | X
| align="center" | -
| colspan="3" align="center" | X
| align="center" | X
|-
| Strom sparende Anwendungen
| align="center" | - 300 nA Sleep<ref name="STM_Power">[http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1295], [[STM32]] L1 series of ultra-low-power MCUs</ref> 230 μA/MHz
| align="center" | - 100 nA Sleep<ref name="AVR_Power1">[http://www.atmel.com/technologies/lowpower/default.aspx], Atmel picoPower Technology</ref> <ref name="AVR_Power2">[http:/www.futurlec.com/News/Atmel/PicoPower.shtml], Atmel Releases New picoPower AVR Microcontrollers</ref> 340 μA/MHz
| align="center" | -
| colspan="2" align="center" | X 9 nA Sleep<ref name="PIC_XLPvsTI">[http://ww1.microchip.com/downloads/en/DeviceDoc/39989A.pdf], The Truth about Power Consumption in PIC® MCUs with
XLP Technology vs. TI’s MSP430</ref><ref name="PIC_XLP">[http://ww1.microchip.com/downloads/en/DeviceDoc/30009941F.pdf], nanoWatt XLP eXtreme Low Power PIC® Microcontrollers</ref> 35 μA/MHz || align="center" | -
| align="center" | X 100 nA Sleep<ref name="TI_Power1">[http://www.ti.com/lit/wp/slay015/slay015.pdf], Texas Instruments: Ultra-Low Power Comparison: MSP430 vs. Microchip XLP</ref><ref name="TI_Power2">[http://www.ti.com/ww/mx/multimedia/webcasts/Aspectos_Generales_MSP430.pdf], Texas Instruments: Meet MSP430</ref> 100 μA/MHz
|-
| Multithreading, RTOS, Schedulern
| align="center" | X
| align="center" | - <ref name="AVR_RTOS1">[http://www.freertos.org/a00098.html], Atmel AVR freeRTOS port</ref><ref name="AVR_RTOS2">[http://www.femtoos.org/], Femto OS: RTOS for small MCU's like AVR</ref>
| align="center" | -
| align="center" | - <ref name="PIC_RTOS2">[http://www.freertos.org/a00097.html], Microchip PICmicro (PIC18) freeRTOS Port</ref> <ref name="PIC_RTOS3">[http://www.pumpkininc.com/], Salvo RTOS</ref>|| align="center" | X<ref name="PIC_RTOS">[http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en531543&redirects=rtos], 3rd Party RTOS selection guide</ref> || align="center" | X<ref name="PIC_RTOS" />
| align="center" | X <ref name="TI_RTOS">[http://processors.wiki.ti.com/index.php/MSP430_Real_Time_Operating_Systems_Overview], TI Wiki: MSP430 Real Time Operating Systems Overview</ref>
|-
| Besonders große, speicherintensive Programme z.B. Grafiken, Fonts
| align="center" | bis 2MB Flash bis 256kB SRAM <ref name="STM32Ueb">[http://www.st.com/web/en/catalog/mmc/FM141/SC1169], Übersicht aller verfügbaren [[STM32]] µC von ST</ref>
| colspan="2" align="center" | bis 256kB Flash bis 16kB SRAM
| align="center" | bis 128kB Flash bis 4kB SRAM || bis 2MB Flash bis 98kB SRAM || bis 2MB Flash bis 512kB SRAM
| align="center" | bis 512KB Flash bis 66kB SRAM
|-
| Sehr viel PWM mit komplexem Timing
| align="center" | X
| align="center" | AT90Spwm
| align="center" | -
| align="center" | - || align="center" | X || align="center" | X
| align="center" | O
|-
| Deutschsprachige Community
| align="center" | O
| align="center" | X
| align="center" | X
| align="center" | X <ref name="PIC-Projekte">[http://pic-projekte.de/], pic-projekte.de</ref> <ref name="SPRUT">[http://www.sprut.de/], sprut.de</ref> || align="center" | - || align="center" | -
| align="center" | -
|-
| Anzahl möglicher HW-Breakpoints
| align="center" | 4 bis 6
| colspan="2" align="center" | 2
| align="center" | 1 bis 5 <ref name="PIC_HWBP">[http://www.microchip.com/stellent/groups/SiteComm_sg/documents/DeviceDoc/en556761.pdf], PIC Hardware Breakpoints (Seite 6)</ref> || align="center" | 1 bis 10 <ref name="PIC_HWBP"/> || align="center" | 6<ref name="PIC_HWBP"/>
| align="center" | 2
|}
* X = ja
* O = Teilweise, Einschränkungen
* - = nicht empfohlen
Nur um nicht zu verwirren, auch wenn Teile "nicht empfohlen" sind, heißt das nicht dass es mit dem Prozessor nicht geht, vielmehr dass es mehr Aufwand ist das zu realisieren oder mehr Einschränkungen hat.
Viele Eigenschaften weisen nur bestimmte Modelle einer Mikrocontrollerfamilie auf. Der Wechsel innerhalb einer Familie gestaltet sich jedoch oft einfach (z.B. innerhalb [[STM32]] oder innerhalb PIC24).

Die Spalte Cortex zeigt die Prozessorfamilie von STM32F0xx bis STM32F4xx mit einem Cortex-M0 oder M3/M4 Kern. Die technischen Daten sind ähnlich anderer Hersteller die auch einen Cortex-Mx Kern verbauen wie z.B. NXP ([[LPC1xxx]]), Freescale, Atmel, TI, Toshiba, usw. Jedoch bietet ST mit dem [[STM32]] eine hohe Flexibilität an Gehäuse-Variationen (vergleichbar mit NXP [[LPC1xxx]]) und ist privat recht leicht beschaffbar. Übersicht aller verfügbaren [[STM32]] µC von ST<ref name="STM32Ueb">[http://www.st.com/web/en/catalog/mmc/FM141/SC1169], Übersicht aller verfügbaren [[STM32]] µC von ST</ref>.

Der STM32 ist in der Tat nicht der beste in der Kategorie "Stromsparend", jedoch um eine Alternative mit Cortex-Mx Kern auf zu zeigen:
 "EFM32" von Silabs<ref name="EFM32">[http://www.silabs.com/products/mcu/lowpower/Pages/efm32-energy-modes.aspx], EFM32, der Stromsparende mit Cortex-Mx Kern</ref> benötigt nur 0,9 µA im Sleep Mode.

Die Spalte PIC zeigt die Eigenschaften der 8-Bit PIC18 (vergleichbar mit [[AVR]]), 16-Bit [[PIC24]]/[[dsPIC]] (vergleichbar mit [[MSP430]]) und 32-Bit [[PIC32]] (vergleichbar mit [[STM32]]). Ein Wechsel des Mikrocontrollers innerhalb der Familien ist Codetechnisch problemlos möglich. <ref name="PIC_codeswitch">[http://www.elektor.nl/Uploads/Files/PIC24FIntro_5f082806.pdf], Microchip: Introduction to the 16-bit PIC24F Microcontroller Family</ref> Hardwaretechnisch sind verschiedene Modelle gleicher Familie zudem auch meist Pin-Kompatibel <ref name="PIC_PinCompatibility">[http://ww1.microchip.com/downloads/en/DeviceDoc/00148m.pdf], Microchip: 2007 Product Selector Guide (Seite 114 ff.)</ref> sodass ohne Design-Änderung zwischen verschiedenen Modellen gewechselt werden kann.
Ein Wechsel zwischen den Familien ist Architekturbedingt aufwendiger, vor allem von 8-Bit auf 16/32-Bit. <ref name="PIC_8to16Migration">[http://ww1.microchip.com/downloads/en/DeviceDoc/39764a.pdf], Microchip: PIC18F to PIC24F Migration: An Overview</ref> Aufgrund gleichbleibender IDE (Mplab) sowie gleichbleibenden Libraries bei Verwendung einer Hochsprache (C) jedoch vor allem zwischen 16-Bit und 32-Bit ohne weitere Probleme möglich <ref name="PIC_16to32Migration">[http://www.embedded.com/design/mcus-processors-and-socs/4007683/Practical-migration-from-8-16-to-32-bit-PIC], Artikel: Practical migration from 8-/16- to 32-bit PIC</ref>.
 Ein PIC10/12/16 ist für den Einstieg nicht empfohlen, da diese Architekturbedingt viele Einschränkungen haben, die eher hinderlich für das Lernen sind.

Der "[[Arduino]]" ist kein eigenständiger Prozessor, sondern ein fertiges Board mit einer "[[Arduino]]" Programmierumgebung (und einem AVR Prozessor), extra geschaffen für Einsteiger. Allerdings ist da der Lerneffekt viel geringer da man den Prozessor mit der [[Arduino]]-Software programmiert und nicht direkt die Register. Anderseits ist der Arduino besser für jemanden geeignet, der eigentlich nicht lernen möchte, sondern nur mal schnell etwas steuern/basteln will und so ohne großartige µC Kenntnisse zum Ziel kommt. Für diese Zielgruppe ist der Arduino perfekt.

<references />

= Unwichtige Randbedingungen =

Oftmals werden fälschlicherweise Argumente für oder gegen eine µC-Familie ausgesprochen, die in der Praxis '''zum Einstieg''' (bei konkreten Anwendungen kann das anders aussehen) eher unwichtig sind.

* Spannungsversorgung 3,3V / 5V (Wobei z.B Atmel XMega keine 5V Tolerante Eingänge besitzt)
* 8 (z.B. [[AVR]]), 16 (z.B. [[MSP430]]) oder 32 (z.B. [[STM32]]) Bit
* Prozessorkern Cortex-M0/M3/M4, MIPS, ARM7/9/..., AVR-RISC, PIC-RISC, 8051, ...
* Interrupt System mit mehr oder weniger Features
* Programmiersprache (Assembler, Basic, C, C++, Pascal)
* Programmierumgebung - ist ohnehin Geschmackssache
* Assembler verstehen (Sollte nur theoretisch verstanden werden, ein Programm sollte in einer Hochsprache geschrieben sein)
* DIL Gehäuse - steckbretttauglich ([[STM32]]-Prozessoren gibt es auch fertig gelötet auf einem steckbretttauglichen Board)
* Programmieradapter - solange er auch debuggen kann
* zu 90% reicht doch ein kleiner Prozessor ([[AVR]]/PIC) - und für die restlichen kann man immer noch einen großen nehmen. Warum also nicht gleich einen großen nehmen?

= Kosten =

Grobe Abschätzung was das alles denn kosten wird. Hier sind nur einige Beispiele gezeigt (Einzelpreise bei Bezugsquellen in Deutschland).

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Board || [[STM32]] || [[AVR]] || PIC18/24/32 || [[MSP430]] || [[Arduino]]
|-
| Demo-Board
| align="center" | <ref name="STM32F4DISCOVERY">[http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419], ST STM32F4DISCOVERY Demoboard</ref> 9..20€ (incl. Programmieradapter und Debugger)
| align="center" | 5..500€, z.B. [[Arduino]] || align="center"| <ref name="PICDEMOBOARD">[http://www.microchipdirect.com/ProductDetails.aspx?Catalog=BuyMicrochip&Category=Starter%20Kits&mid=1&lmid=610], Microchip Demoboard</ref> durchschnittlich 18€ .. 50€ (Für 16 und 32bit auch mit integriertem Debugger + Programmer)
| align="center" | <ref name="MSP430DEMOBOARD">[http://www.ti.com/tool/msp-exp430fr5739], MSP430 Demoboard</ref> ~35€
| align="center" | 20€
|-
| Steckbrettaugliches Board
| align="center" | s.o. oder <ref name="STM32F405Board">[http://re.reworld.eu/de/produkte/s64dil-405/index.htm], S64DIL-405 mit STM32F405</ref>S64DIL-405 30€, STM32F103C8 4€ (China)
| align="center" | DIP IC
| align="center" | DIP IC oder Microstick
| align="center" | DIP IC
| align="center" | ab ca. 1.50€ (Pro Mini, China)
|-
| Einzelchip (Einzelstückpreise)
| align="center"| 2..15€ nur SMD (TSSOP..LQFP..BGA)
| align="center"|0,6–5€ SMD + DIP
| align="center"|0,5-15€ SMD + DIP
| align="center"|??
| align="center"|siehe AVR
|-
| Programmieradapter
| align="center" | 0€ da Bootloader (ROM) UART / USB usw. unterstützt
| align="center" | ab 4€
| align="center" |
| align="center" |
| align="center" |
|-
| Programmieradapter mit Debugger
| align="center" | s.o. oder z.B <ref name="JLINKEDU">[http://www.segger.com/j-link-edu.html], Segger J-LINK EDU</ref> Segger J-LINK EDU 50€ (sehr schnell und unterstützt viele Prozessoren)
| align="center" | <ref name="AVRDragon">[http://www.atmel.com/tools/AVRDRAGON.aspx], Atmel AVR Dragon</ref> AVR Dragon 40€ <ref name="JTAGICE3">[http://www.atmel.com/tools/JTAGICE3.aspx], AT JTAG ICE3</ref> AT JTAG ICE3 99€
| align="center" | <ref name="PICKIT3">[http://www.microchipdirect.com/ProductSearch.aspx?keywords=PG164130], Microchip PICkit 3</ref> PICkit 3 30€
| align="center" | z.B. Dragon 50€
| align="center" | 20€ (Man muss DebugWire aktivieren)
|}

Das Demo-Board sollte ein Board sein, nicht zu teuer, um die ersten Erfahrungen zu sammeln. Wenn einem der Prozessor gefällt, so kann man später immer noch mit einem zweiten Demo-Board, z.B. mit Display aufrüsten.

Wenn man gerne mit einem Steckbrett sich die Schaltung zusammen stecken möchte, so kann man entweder die benötigten Drähte am Demo-Board anlöten oder bei z.B. [[AVR]]/[[PIC]] Prozessoren gibt es Ausführungen im DIL Gehäuse, die direkt steckbar sind.

Ein Programmieradapter sollte unbedingt auch einen Debugger beinhalten. Denn für den Start ist es ungemein hilfreich zu sehen was im Prozessor gerade geschieht. Die JTAG-Adapter für einen [[STM32]] Prozessor sind alle Debugger-Tauglich. Für die [[AVR]] Controller gibt es auch oft reine Programmer (AVR ISP oder Selbstbau-Lösungen über die serielle oder parallele Schnittstelle) welche den Mikrocontroller nur beschreiben können. Für die [[PIC]] Controller werden solche reinen Programmer vereinzelt auch noch angeboten. Sinvoller sind hingegen Debugger, die die Ausführung eines Mikrocontrollers anhalten können um die aktuelle Position im Programmcode, Variableninhalt, Register, ... auszulesen bzw. zur Laufzeit zu ändern.

Der für den [[STM32]] empfohlene Segger J-LINK EDU ist zwar nicht der günstigste (z.B. auf einem STM32F4DISCOVERY Board ist ein ST-LINK/V2 mit drauf, den man für andere [[STM32]] nutzen kann) aber eines der besten, mit sehr guten Software-Tools und nutzbar für alle Prozessoren mit ARM-Kern (ARM7/9/11/... Cortex-Mx der Hersteller Atmel, Energy Micro, Freescale, Holtek, TI, NXP, Nuvoton, ST, Toshiba, ... unter Windows, Linux und MAC). Niemals am Werkzeug sparen und man hat viel mehr Freude bei der Arbeit.

<references />

= Programmierumgebungen=

Bei den Programmierumgebungen gibt es zu allen Prozessorfamilien kostenlose und Leistungsfähige Software

{| {{Tabelle}}
|- bgcolor="#d0d0ff"
! Betriebssystem || [[STM32]] || [[AVR]] || [[PIC]] || [[MSP430]] || [[Arduino]]
|-
| Windows
| align="center"|[http://www.coocox.org/CooCox_CoIDE.htm CooCox, EmBitz, Eclipse]
| align="center"|Atmel-Studio
| align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPLAB X] (IDE inklusive compiler)
| align="center"|TI Code Composer Studio
| align="center"|[[Arduino]] IDE
|-
| Linux
| align="center"|[http://eclipse.org/downloads/ Eclipse IDE for C/C++ Developers]
| align="center"|z.B. [http://eclipse.org/downloads/ Eclipse IDE for C/C++ Developers]
| align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPLAB X] (IDE inklusive compiler)
| align="center"|TI Code Composer Studio
| align="center"|[[Arduino]] IDE
|-
| MacOS
| align="center"|[http://eclipse.org/downloads/ Eclipse IDE for C/C++ Developers]
| align="center"|??
| align="center"|[http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPLAB X] (IDE inklusive compiler)
| align="center"|TI Code Composer Studio
| align="center"|[[Arduino]] IDE
|}

natürlich gibt es noch viele weitere (für [[STM32]] siehe [[STM32#Programmierung]]), es sollte jedoch nur die jeweils einfachste kostenlose (und ohne Codebegrenzung) für den ersten Einstieg gezeigt werden.

* [http://www.coocox.org/CooCox_CoIDE.htm CooCox] Anleitung wie man innerhalb einer Stunde die LED eines Nagel neuen STM32F4DISCOVERY Boards zum blinken bekommt, Artikel: [[STM32 CooCox Installation]]. Diese Anleitung ist eine Schritt-Für-Schritt Anleitung um den aller ersten Start zu vereinfachen.
* Mit [http://www.coocox.org/CooCox_CoIDE.htm CooCox] können sehr viele Prozessoren mit Cortex-M0, M3 und M4 Kern programmiert werden. Unter anderem der Firmen Atmel, Energy Micro, Freescale, Holtek, TI, NXP, Nuvoton, ST und Toshiba. Somit hat man eine Entwicklungsumgebung und ist damit nicht an einen Hersteller der µC gebunden.
* Mit [http://www.microchip.com/pagehandler/en-us/family/mplabx/ MPLAB X] können alle Prozessoren von Microchip (z.B. PIC18, PIC24, PIC32, dsPIC) programmiert werden.

= Dokumentation=

Bevor man sich für einen Prozessor entscheidet, sollte man unbedingt deren Dokumentation mal zumindest überfliegen und auch deren Errata lesen. Nicht dass man eine Anwendung erstellen möchte und stellt hinterher fest, dass genau dieser Teil so buggy ist, dass er nicht genutzt werden kann.

Beim [[STM32]] hat die Dokumentation doch recht viele Seiten, viel mehr als bei einem [[AVR]] oder PIC, dabei ist vieles eher knapp beschrieben. Der Aufbau der [[STM32]] Dokumentation ist [http://www.mikrocontroller.net/articles/STM32#Struktur_der_Dokumentation: hier] beschrieben.
 Bei den PICs ist die Dokumentation wiederum anders strukturiert, [http://www.mikrocontroller.net/articles/PIC#Dokumenatation siehe im PIC Artikel].

Für die [[STM32]], [[AVR]] und [[PIC]] Mikrocontroller gibt es zudem viele, auch deutschsprachige Einsteigerhilfestellungen und Tutorials.

Parallel zur Dokumentation sollte man sich auch die Demo-Beispiele der Hersteller anschauen, dann wird vieles gleich verständlicher.

Eine Übersicht über die Funktionen gibt es im Artikel: [[STM32]]

= Die Arbeit mit dem [[STM32]]=

Zu erst einmal SOOO groß sind die Unterschiede zwischen den einzelnen Prozessoren nicht. Alle haben Ein-/Ausgänge und um mittels einem Port-Pin eine LED ansteuern zu können, muss bei jedem Prozessor der Pin erst einmal parametriert werden, egal ob das jetzt ein [[STM32]] oder ein [[AVR]] oder ein [[MSP430]] ist. Nur hat man bei einem [[STM32]] doch einige Funktionen mehr, z.B. zuschaltbarer Pull-Up oder Pull-Down Widerstand und spezielle Setz-Rücksetzregister, die andere Prozessoren nicht haben, jedoch das Programmieren vereinfachen.
Der Haupt-Unterschied zu den anderen Prozessoren ist, dass der [[STM32]] so viele Peripherie-Module beherbergt, dass man die einzeln immer mit einem Clock aktivieren muss, denn damit lässt sich viel Strom sparen.

Und mal ganz ehrlich die Diskussion, welcher µc einfacher zu konfigurieren ist, ist doch absoluter Unsinn. Der Weg ist immer der Gleiche:
*1. Blick ins Datenblatt, welche Register für diese Funktion benötigt werden.
*2. Werte ermitteln, die in die Register eingetragen werden.
*3. Werte ins Register schreiben. Da machte es GAR KEINEN UNTERSCHIED, ob es ein [[AVR]], 8051/2, [[ARM]],...... ist.

Stimmt schon, es gibt Unterschiede. Die Register haben anderen Namen, andere Adressen, andere Bitbedeutungen,...
Aber es steht doch alles im Datenblatt. Und ob ich jetzt einen [[AVR]] oder einen [[ARM]] das erste Mal vor mir liegen hab. Ich brauch in allen Fällen die oben beschriebenen Schritte.

Das Interruptsystem ist bei einem [[STM32]] zusätzlich priorisiert. Damit kann man festlegen, welcher Interrupt vorrangig bearbeitet wird. Die Prioritätenvergabe ist auch kein Hexenwerk.

Zu allen Prozessoren liefern die jeweiligen Hersteller umfangreiche Demo-Codes und Libraries mit. Meist sind alle in C geschrieben, daher sollte auch die Programmiersprache C verwendet werden. Vor allem auch wenn man berufliche Absichten verfolgt.

Und wenn man einen [[STM32]] kann, dann ist ein Umstieg auf einen [[LPC1xxx]] (NXP) oder andere Hersteller überhaupt kein Problem (*), denn die bieten ebenfalls Prozessoren mit Cortex-M3 Kern und man kann diese mit der gleichen Programmierumgebung programmieren. Somit ist man nicht zwingend herstellerabhängig. (* jeder Hersteller verbaut seine eigene Peripherie, die andere Funktionalitäten haben.)

Mit einem [[STM32]] kann man als Hobby-Baster und professionell nahezu alle Anwendungen realisieren. Der hat genügend RAM und FLASH Speicher und auch genügend Geschwindigkeit. Viele Gehäuse-Varianten, um kleine bis hin zu größere Geräte zu erstellen. Viele Schnittstellen sind im Artikel [[STM32]] beschrieben.

Für den Einstig gibt es diverse, auch deutschsprachige, Tutorials im Netz. Eine Übersicht ist [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials hier auf der STM32 Seite]. (Beispiel: [http://diller-technologies.de/stm32_wide.html STM32 Tutorial in Deutsch von Diller Technologies])
 Wobei dazugesagt werden muss, dass diese meist auf die Standard ST-Libs aufbauen. Diese Libs vereinfachen zum einen das Ansteuern/die Benutzung der Peripheriefunktion zum anderen muss man diese erst mal kennenlernen. Vereinfacht wird das da ALLE [http://www.st.com/stonline/stappl/productcatalog/app?page=partNumberSearchPage&levelid=SS1577&parentid=1743&resourcetype=SW ST-Demo-Codebeispiele] ebenfalls auf diesen Lib's basieren und somit wird der Wechsel innerhalb des [[STM32]] deutlich vereinfacht.
 STM32F4xx Library von ST: [http://www.st.com/web/en/catalog/tools/PF257901# "STSW-STM32065 STM32F4 DSP and standard peripherals library"] incl. Dokumentation und Demo-Projekte zu allen CPU-Funktionen.

Der einzige Nachteil beim [[STM32]]: Man muss etwas mehr lesen, da eine Peripherie doch viel mehr Funktionalität hat (sofern man das Modul überhaupt benötigt). Ansonsten kenne ich nicht wirklich einen Grund, warum man als Neueinsteiger keinen [[STM32]] nehmen sollte.

= Programmiersprachen =
* Wie bei vielen anderen Controllern wird beim [[STM32]] auch hauptsächlich C und C++ verwendet. Kennen sollte man die Programmiersprache C schon, wenn man davon noch keine Ahnung hat dann sollte man erst mal mittels einem Tutorial auf einem PC ein Konsoleprogramm schreiben, sodass man es einigermaßen kennen lernt. Hier im Forum gibt es ebenfalls Artikel dazu. Zielt man auf die (spätere) Anwendung in der Industrie, sollte aufgrund der Verbreitung auf jeden Fall C (oder C++) gewählt werden; außerdem sind die meisten verfügbaren Libraries in C geschrieben.
* Assembler sollte man nur grob verstehen, Details wie ein Befehl arbeitet ist unwichtig. Selbst wenn man die Zyklen für einen Funktionsaufruf wissen will, so bietet der [[STM32]] (Cortex-M3) einen Cycle-Counter den man auslesen kann; durch die komplexere Pipeline und Cache-Effekte sind die Laufzeiten allerdings nicht genau vorhersehbar. Wird zyklengenause Timing benötigt, sollten Timer verwendet werden - davon hat der [[STM32]] genug.

Der 32bit-Adressraum, der RAM, Flash, I/O-Register vereinheitlicht ansprechen kann (im Gegensatz zu z.B. [[AVR]]) ist ideal für eine Verwendung durch Hochsprachen; bei Pointern muss keine zusätzliche Information verwaltet werden, in welche Art Speicher sie zeigen. Die Adresse gibt dies eindeutig an (es gibt nur '''eine''' Adresse 42, und nicht 2 wie z.B. beim [[AVR]] (Flash, RAM & I/O)) und die Hardware spricht automatisch den richtigen Speicher an. Die Möglichkeiten zur Offset-Adressierung, der Barrel-Shifter, Divsions-Einheit, die FPU (bei STM32F4), Interrupt-Modell etc. begünstigen ebenfalls die Erzeugung effizienteren Codes. Außerdem haben die [[STM32]] einfach mehr "rohe Leistung", d.h. mehr Flash/RAM-Speicher und höhere Taktfrequenzen. 
 
'''Folgerung''': Die Programmierung in Hochsprachen ist '''bequemer als bei 8-Bittern''', denn man muss sich einfach weniger Gedanken machen, ob der Compiler ein Programm nun effizent umsetzen kann (kann man natürlich trotzdem machen, um noch mehr Leistung "herauszuquetschen", wenn man will).

= Weitere Randbedingungen für die Entscheidung=

Der wichtige Punkt, der oftmals auch vergessen wird: die Beschaffbarkeit. Wenn jemand einen Renesas M16C oder Fujitsu empfiehlt, dann sucht man erst mal und findet nur wenige vereinzelte die man privat kaufen kann.

Oder auch die Unterstützung im Internet - ist bei einigen Exoten spärlich. Dieses Forum bietet die beste Hilfe für [[AVR]], PIC, [[MSP430]], [[LPC1xxx]] und [[STM32]].

Andere Prozessoren sind schon sehr alt, bzw. nicht mehr modern da deren Peripherie zum Teil doch recht eingeschränkte Funktionalität bietet. z.B. viele 8051 Typen oder PIC16 (oder auch dsPIC30). Die mögen für Mini-Anwenungen gut sein, aber wer will den schon gerne sich extra für eine Kleinanwendung mit einem kleinen µC auseinandersetzen, wenn er schon einen [[STM32]] kennt, mit dem er alles machen kann (und sich bereits gute Funktionen geschrieben hat)?

Daher mein Resümee: wer nicht gerade auf den Kopf gefallen ist, der kann getrost mit einem [[STM32]] starten. Ein [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419?s_searchtype=keyword STM32F4DISCOVERY] Board kostet nur ca. 20 EUR - und mehr muss für den ersten Start nicht investiert werden - wenn es doch zu komplex sein sollte gibt es hier im Forum auch viel Hilfe. Jedenfalls sind diese 20 EUR wirklich keine große Investition.
 Wer berufliche Absichten verfolgt, sollte zu einem späteren Zeitpunk sich unbedingt auch mit einem zweiten, anderen Prozessor beschäftigen um so die nötigen Erfahrungen zu gewinnen.

Ein paar Forenbeiträge:
* [http://www.mikrocontroller.net/topic/317792#3481048 "Klein anfangen!" heisst die Devise]
* [http://www.mikrocontroller.net/topic/312330#3483218 Einen 8-Bitter nehme ich nur noch aus "Nostalgiegründen"]

= Übersicht CPU Funktionalitäten=

In diesem Abschnitt ist kurz gezeigt welche Möglichkeiten die CPUs bei den oben empfohlenen Einsteigerboards haben

=== STM32F407 - vom STM32F4DISCOVERY Board ===

{| class="wikitable"
|-
| [[Datei:STM32F407.png|mini|x400px]]
| [[Datei:stm32f4_discovery2.png|mini|x400px]]
|-
| [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140?s_searchtype=partnumber Blockdiagramm STM32F407]
| [http://www.st.com/web/en/catalog/tools/FM116/SC959/SS1532/PF252419 STM32F4DISCOVERY Demoboard]
|}

Es sind sehr viele Peripheriemodule im µC implementiert. Jedes einzelne Peripherie-Modul (z.B. Ethernet, USB, CAN, Timer, AD-Wandler, usw.) kann aktiviert werden, indem der Clock freigeschaltet wird. So lange der Clock nicht aktiviert wurde verhält sich das Modul so als ob es nicht vorhanden wäre und beeinträchtigt in keinster Weise die Bearbeitung vom Prozessor. Somit lässt sich der Stromverbrauch senken.

Eine ganze Auflistung der Einzelmodule steht im Artikel: [[STM32]] und [http://www.st.com/web/en/catalog/mmc/FM141/SC1169 auf der Homepage von ST]

Zu Anfang mag vielleicht die interne Busstruktur verwirren, jedoch braucht man diese nicht beachten. Wenn nun die CPU auf UART4 zugreifen möchte, so gehen die Daten durch die Busse "AHB1" > "ABH/APB1-Bridge" > "APB1". Dies erledigt der µC ganz von alleine. Diese Unterteilung ist technisch nötig, da die Peripheriebusse nicht mit dem gleichen Prozessortakt betrieben werden (wie z.B. bei [[MSP430], siehe Schaubild unten), die "Bridge" managt ganz alleine das Handling und generiert automatisch Wait-Befehle für die CPU.
 Die "AHB-Bus-Matrix" ist ebenfalls für den Anwender meist uninteressant. ST hat damit ein System geschaffen, damit die CPU, DMAs und Displaycontroller gleichzeitig auf die verschiedenen RAM-Bereiche zugreifen können um mehr Daten parallel zu verarbeiten. Somit braucht man diese Matrix erst mal nicht beachten.

Ebenso braucht man zu Anfang sich auch keine Gedanken um den Prozessortakt machen, wenn man nichts initialisiert so läuft der STM32F4xx mit dem internen RC-Oszillator von 16MHz und die Peripheriebusse laufen ebenfalls mit der gleichen Geschwindigkeit. Erst wenn man später umfangreichere Applikationen schreibt, bei der die 16MHz nicht mehr reichen, so kann man die PLL aktivieren und die Taktrate flexibel bis auf 168MHz hochsetzen. (Siehe Demo-Projekt von [[STM32 CooCox Installation]].)

=== [[AVR]] ([[Arduino]])===

Details können im Artikel [[AVR]] gelesen werden.

=== PIC18, PIC24, PIC32===

Details können im Artikel [[PIC]] gelesen werden.

=== MSP430 - vom MSP-EXP430FR5739 Experimentier-Board===

{| class="wikitable"
|-
| [[Datei:MSP430FR5739.gif|mini|450px]]
| [[Datei:MSP-EXP430FR5739.jpg|mini|x350px]]
|-
| Blockdiagramm MSP430FR5739
| MSP-EXP430FR5739 Demoboard
|}

Details können im Artikel [[MSP430]] gelesen werden.

=== LPC1x d.h. Cortex -M0 & -M3 Familie von NXP ===
Details können aus dem Leitartikel [[LPC1xxx]] und den darin verlinkten Artikeln entnommen werden.

= Tipps und Tricks bei der Programmierung=

===Interruptcontroller vom Cortex-M3/M4===

Der "Nested Vectored Interrupt Controller" (NVIC) ist eine Funktion der ARMv7M Architektur und ist über die CMSIS verwendbar.

Beim STM32 hat jeder Interrupt eine Priorität von 4 Bit (bei ARMv7M je nach Implementation bis 8bit möglich). Diese 4 Bit können in eine "pre-emption priority" und "subpriority" unterteilt werden.

Beispiel 2 Bit zu 2 Bit Unterteilung:
<syntaxhighlight lang="c">
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); // 2 Bits für pre-emption priority
</syntaxhighlight>

Somit kann "pre-emption priority" den Wert 0..3 und "subpriority" auch 0..3 erhalten. Um so kleiner die Zahl ist um so höherwertig ist der Interrupt.

Beispiel:
 ISR1 Pre 2 / Sub 1
 ISR2 Pre 1 / Sub 1
 ISR3 Pre 1 / Sub 2

Wenn jetzt ISR1 kommt, dann wird der aufgerufen. Kommt während dem ein ISR2 dann darf der den ISR1 unterbrechen, da er eine höhere "pre-emption priority" Wertigkeit hat.

Wenn ISR2 bereits aktiv ist, so darf ISR3 diesen nicht unterbrechen, ISR1 ebenfalls nicht.

Wenn ISR2 und ISR3 gleichzeitig kommen, so wird zu erst ISR2 bearbeitet, anschließend ISR3 da beide die gleiche "pre-emption priority" haben fällt die Entscheidung anhand der "subpriority".

Beispiel Interrupt Konfiguration für USART1 mittels CMSIS-Funktionen:
<syntaxhighlight lang="c">
NVIC_InitTypeDef NVIC_InitSt;
NVIC_InitSt.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitSt.NVIC_IRQChannelPreemptionPriority = 3; // << Tiefe Prio
NVIC_InitSt.NVIC_IRQChannelSubPriority = 1;
NVIC_InitSt.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitSt);
</syntaxhighlight>

=== Taktzeitberechnung und Überwachung===

Bei zeitkritischen Applikationen stellt sich immer wieder die Frage wie viele Prozessortakte nun die Funktion verbraucht. Ist der Interrupt auch wirklich nicht zu lange und wie viel Reserve gibt es noch?
 Der ARMv7M -Kern hat dafür extra einen Takt-Zähler in der DWT-Einheit implementiert, den man mittels der CMSIS nutzen kann:

<syntaxhighlight lang="c">
#include <stdint.h> // Für die Standard-Typen uint32_t etc.
#include <stm32f4xx.h> // Hier die Header-Datei der CMSIS für die jeweilige Familie verwenden.

// DWT-Einheit aktivieren
inline void DWT_Enable() {
CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
}
// Takt-Zähler - Messen der Anzahl der Befehle des Prozessors:
inline void DWT_CycCounterEn () {
DWT->CTRL = 0x40000001;
}
inline void DWT_CycCounterDis () {
DWT->CTRL = 0x40000000;
}
inline uint32_t DWT_CycCounterRead () {
return DWT->CYCCNT;
}
inline void DWT_CycCounterClear () {
DWT->CYCCNT = 0;
}

int main () {
// ... Programmcode ...

// Systick-Zähler benutzen
DWT_Enable(); // DWT-Einheit aktivieren
DWT_CycCounterEn (); // Zähler aktivieren
DWT_CycCounterClear (); // Zähler löschen
// ... Programmbearbeitung ...
uint32_t iZ = DWT_CycCounterRead (); // Zähler auslesen

// ... weiterer Programmcode ...
}
</syntaxhighlight>

In iZ steht nun wie viele Maschinentakte der Prozessor für die Bearbeitung benötigt hat und kann mit folgender Formel umgerechnet werden:

Zeit in µSec = iZ / CPU-Takt in MHz

= FAQ - Anfängerfragen=

* Muss ich, wenn ich die Debugging-Funktionen nutzen möchte einen JTAG Adapter anschließen? - Ja. Auf dem STM32F4DISCOVERY ist jedoch bereits einer mit drauf.
* Mit diesem kann ich dann den µC auch programmieren? - Ja, programmieren und debuggen.
* Ich möchte eine eigene Platine entwickelt, jedoch der 20polige [[JTAG]]-Anschluss ist mir zu groß, gibt es eine Alternative? - Ja, [http://www.mikrocontroller.net/articles/JTAG#Der_10-polige_JTAG_Stecker_von_mmvisual "Der 10-polige JTAG Stecker von mmvisual"]

= Weblinks, Foren, Communities, Tutorials =
* [[STM32]] Hauptartikel, [http://www.mikrocontroller.net/articles/STM32#Weblinks.2C_Foren.2C_Communities.2C_Tutorials dortige Linksammlung]
* [http://www.mikrocontroller.net/topic/319328 Diskussion zum Artikel]
* [[STM32 CooCox Installation]]
* [[STM32 Eclipse Installation]]
* [https://www.mikrocontroller.net/topic/423300#new Totzeitrechner für STM32]
* [[LPC1xxx für Umsteiger]]
* [http://stefanfrings.de/stm32/index.html Notizen zu ARM Cortex M3 Mikrocontrollern der STM32F1 Serie]

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

Sonnenfolger / Heliostat

2017-02-28T06:08:03Z

Kichi: Änderung 95389 von 46.0.218.231 (Diskussion) rückgängig gemacht.

== Einleitung ==
===Allgemeines===
Ursache für den Tageslauf der Sonne ist die Rotation der Erde um sich selbst. Die Höhen-Änderung der Sonnenbahn resultiert aus dem jährlichen Umlauf der Erde (Erdbahn) um die Sonne in Kombination mit der im Weltall annähernd fixen Richtung der gegen die Erdbahn geneigten Erdachse (Schiefe der Ekliptik). (Quelle Wikipedia)

Würde man die Sonne an jedem Tag des Jahres immer genau um 12:00 Uhr Mittags (DCF77 Uhr) fotografieren und die Fotos alle übereinander legen, erhielte man die Analemma-Figur mit zusätzlichen Sprüngen von einer Stunde Ende März und Ende Oktober. Das heißt, eine Sonnenuhr geht bis zu 15 Minuten zuzüglich Sommerzeitverschiebung falsch, da die Sonne mal rechts und mal links von der Position steht, die man vereinfacht erwarten würde.

[[Bild:Analemma_pattern_in_the_sky.jpg|400px]]

(Foto Quelle Wikipedia)

Wie alle sicherlich beobachtet haben, ändert sich je nach Jahreszeit und nach dem Breitengrad der Aufstellung der Solaranlage die Sonnenhöhe (Höhenwinkel, Azimuth)

Weiterhin leben wir in einer recht großen Zeitzone vom östlichsten Zipfel von Norwegen bis nach Spanien. Daher kann die Sonne um 12:00 Uhr nicht überall genau im Süden stehen. Je nach Längengrad der Aufstellung der Solaranlage ändert sich die Himmelsrichtung für die Stellung der Sonne in der Mittagszeit. Hinzu kommt die Sommer- Winterzeitumstellung.

===Lösungsansätze===
Durch eine Nachführung wird entweder eine Solarzelle genau zur Sonne ausgerichtet oder ein Spiegel lenkt das Sonnenlicht auf einen Zielpunkt. Der Spiegel muss dann auf der Winkelhalbierenden zwischen Sonnenstand und dem Ziel stehen.

Es kann generell zwischen analogen Lösungen mit Messung der Helligkeit ohne Inteligenz, Messung der Helligkeit mit Mikrocontrollerauswertung und Uhrzeitnachführungen mit Berechung der Sonnenposition unterscheiden. Die Berechnung der Sonnenposition ist durch die oben beschriebene Problematik recht aufwendig, hat aber den Vorteil, dass keine Optik sauber gehalten werden muss.

==einachsige Nachführung==
Zur Nachführung einer Solarzelle oder thermischen Solarpanels kann auf die Nachführung in der vertikalen Achse verzichtet werden. Man spart Mechanik, verliert aber Leistungsausbeute.
Kippt man die Drehachse um einen Winkel der gleich der geographische Breite des Aufstellorts ist nach Norden, so wird der Verlust erheblich minimiert. (Parallaktische Montierung)

===Analog===

[[Bild:Lichtfolger_analog.png|400px]]

hier eine der vielen analogen Lichtfolgerschaltungen. An den Ausgängen wird eine H-Brücke als Motortreiber und ein Getriebemotor angeschlossen.

In der Schaltung befinden sich zwei Spannungsteiler. Zu einen die
Reihenschaltung aus den beiden LDR´s. Werden beide gleichmäßig
beleuchtet, teilt sich die Spannung gleichmäßig auf.
Die Spannung Vcc teilt sich an der Reihenschaltung der Widerstände in
drei Teile auf:
Spannung U1 über Poti R1 und R3, Spannung U2 über Poti R2 und die
Spannung U3 über R4.

Die Spannung U2 ist die Hysterese bei der sich beide Ausgänge auf 0 V
Potential befinden.
Die Spannungen U1 und Vcc-U3 sind die Schaltpunkte.

Google nach: Fensterkomparator

===Mikrocontroller===

[[Bild:Lichtfolger_Tiny.png|400px]]

Ähnliche Signalbildung, aber Auswertung durch einen Tiny. Hier kann die Hysterese und Schaltverzögerungen per Software eingestellt werden.

==zweiachsige Nachführung==
Nach einer Weile an Überlegung habe ich mich für die Lösung mit DCF 77 Uhr, Berechnung des Sonnenstandes und Schrittmotoren entschieden.

===Hardware===

[[Bild:Base_Board_L317_alles.png|400px]]

Beim Anschluss der ISP Schnittstelle bin ich etwas vom "Kanda-Standard" abgewichen und nur Pin10 des Wannensteckers für Masse benutzt. Dadurch waren die Pins 8,6,4 noch für das LCD frei. Zum Programmieren benutze ich einen Adapter, der diese Pins isoliert, um einen Kurzschluss zu vermeiden. Der Vorteil, ich habe nur einen Stecker für das LCD und zur Programmierung.

Download Hardware: [[Media:Heliostep Hardware.zip‎|download zip-File]]

===Software===
Der Programmteil DCF77 Empfang ist von Ulrich Rading, die Sonnenstandsberechnung von Clueso hier aus dem Forum, die LCD Anzeige ist ebenfalls aus dem Forum.
Da möchte ich mich nicht mit falschen Federn schmücken. Aber es blieben noch genügend Herausfordeungen zum Testen und Probieren.

* http://www.mikrocontroller.net/forum/codesammlung?filter=sonne*
* http://www.mikrocontroller.net/topic/111783
* http://www.mikrocontroller.net/topic/121049

====Motortest Software====
Download Software zum Motortest: [[Media:Heliostep 05 Motor Test.zip‎|download zip-File]]

Fährt die Schrittmotre zuerst in die Homeposition. Fährt dann die Steppermotore bei Tastendruck jeweils 2000 Schritte vorwärts, bzw wieder zurück in die Homeposition.

====Heliostat Software====
Download Software zur Steuerung: [[Media:Heliostep_15.zip‎|download zip-File]]

Wartet auf DCF Empfang, fährt den Heliostat in die Homeposition Down und Ost, berechnet die Sonnenposition alle Minute und fährt den Spiegel entsprechend der Berechnung.

Während der Wartezeit auf den ersten gültigen DCF77 Empfang wird das Trägersignal als blinkende 1 oder 0 im Sekundentakt auf den LCD angezeigt. Dies eignet sich gut zur Ausrichtung der DCF Antenne.

Nach dem ersten gültigen Empfang wird nochmals 20 Sekunden auf das Signal Sommer- oder Winterzeit gewartet.
Mit diesem Signal und der aktuellen Uhrzeit wird die UTC Zeit berechnet (MEZ - 1h, oder MESZ - 2h). Die aktuelle Zeit in UTC wird auf dem LCD in der ersten Zeile angezeigt.

Mit der UTC Zeit und dem Standort des Heliostaten wird die Position der Sonne in Radiant berechnet. Die Elevation und der Azimut multipliziert mit jeweils einem Faktor ergeben die Anzahl der Schritte die der jeweilige Schrittmotor fahren muss. Die beiden Faktoren werden in der zweiten Zeile auf den LCD angezeigt.

===Video Mechanik===
Hier noch ein kleiner Videofilm von der Mechanik:

http://www.youtube.com/watch?v=s7gXmlWX7Ro

== Links ==

* http://de.wikipedia.org/wiki/Sonnenstand
* http://de.wikipedia.org/wiki/Heliostat
* Programm "Orbitron" http://www.stoff.pl/
* [http://people.ece.cornell.edu/land/courses/ece4760/FinalProjects/s2009/nw59_yt322/nw59_yt322/index.html Heliostat Skylight] (ECE 476 Final Project by Yinan Tang and Nana Wu)
* http://de.wikipedia.org/wiki/Windlast

[[Category:AVR-Projekte]]
[[Kategorie:DCF77]]

STM32

2016-03-10T07:38:37Z

Kichi:

STM32 ist eine Mikrocontroller-Familie von [http://www.st.com/mcu/inchtml-pages-stm32.html ST] mit einer 32-Bit [[ARM]] Cortex-M0/M3/M4 CPU. Diese Architektur ist speziell für den Einsatz in Mikrocontrollern 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 elf STM32-Familien:
* [http://www.st.com/internet/mcu/subclass/1588.jsp STM32F0]
** Cortex M0
** Mikrocontroller zum Einstieg
** Bis 48MHz (38 DMIPS)
* [http://www.st.com/internet/mcu/subclass/1169.jsp STM32F1]
** Cortex M3
** Bis 72MHz (61 DMIPS)
**Verschiedene Unterfamilien:
*** Connectivity line
*** Performance line
*** USB Access line
*** Access Line
*** Value line
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1575 STM32F2]
** Cortex M3
** Bis 120MHz (150 DMIPS)
** Wie die STM32F1 Serie, Camera-Interface, 32-Bit Timer, Crypto-Engine...
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3]
** Cortex M4F
** DSP und FPU
** Bis 72MHz (90 DMIPS)
** 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 M4F
** DSP und FPU
** Bis 180MHz (225 DMIPS)
** Bis zu 2MB Flash
* [http://www.st.com/web/en/catalog/mmc/SC1169/SS1858 STM32F7]
** Cortex M7
** DSP und FPU
** Bis 200MHz (428 DMIPS)
** Mehr Peripherie: SPDIF-IN/OUT, SAI, HDMI-CEC, Dual Quad SPI
** DMA's auch für Ethernet, USB und Chrom-ART
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1817 STM32L0]
** Cortex M0+
** Low Power
** mit LCD Treiber
** Bis 32MHz (26 DMIPS)
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1295 STM32L1]
** Cortex M3
** Low Power
** mit LCD Treiber
** Bis 32MHz (33 DMIPS)
* [http://www.st.com/web/en/web/catalog/mmc/FM141/SC1169/SS1580 STM32L4]
** Cortex M4F
** DSP und FPU
** Ultra Low Power (bis zu 30nA mit I/O Wake-Up)
** Bis 80MHz (100 DMIPS)
** 256KB...1MB Flash, 128KB SRAM
** mit Segment-LCD Treiber
** Digital-Filter für ΣΔ-Modulatoren
* [http://http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1582 STM32T]
** Cortex M3
** 72MHz
** Touch Sensing
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1581 STM32W]
** Cortex M3
** BIS 24MHz
** RF-MCU
[http://www.st.com/web/en/catalog/mmc/FM141/SC1169 Hier eine Übersicht zum Auswählen eines STM32Fxxx]

===Features===
* Cortex-M0 / Cortex-M3 / Cortex-M4F / Cortex-M7 Kern (mit FPU)
* 16KB ... 2MB [[Flash-ROM]]
* 4KB ... 256KB [[Speicher#SRAM|SRAM]]
* 2KB ... 16KB [[Speicher#EEPROM|EEPROM]] (STM32L)
* SDRAM-Controller bei den [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1577/LN1806 STM32F42xxx und STM32F43xxx], bis 512 MByte externer SDRAM addressierbar
* 512 one-time programmable Bytes(STM32F2/4)
* [[IC-Gehäuseformen | Gehäuse]] 20 ... 216 Pins als LCSP, TSSOP, QFN, LQFP und BGA
* Derzeit sind über '''500''' [http://www.st.com/web/en/catalog/mmc/FM141/SC1169 STM32 Derivate/Varianten verfügbar]
* Bis 72MHz CPU-Takt, bis 120MHz beim STM32F2xx, bis 168/180 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. Bis 216MHz CPU-Takt bei STM32F7xx.
* 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)
* TFT Treiber bei STM32F429 / STM32F439
* Spannungsbereich 1,65 ... 3,6V, nur eine Betriebsspannung nötig
* Temperaturbereich bis 125 °C
* Bis zu 168 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), (bis zu 32 PWM Ausgänge)
* 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 3 beim STM32F3xx)
* 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 (bis zu 8 beim STM32F2/F4xx)
* Bis zu 3x [[SPI]] (bis zu 6 beim STM32F4xx)
* Bis zu 2x [[I2S|I²S]]
* Bis zu 2x [[CAN#STMicroelectronics STM32 (Cortex M3/M4)|CAN]]
* Hardware [[CRC]] Unit, bei der STM32F3xx Serie mit einem einstellbaren Polynom
* 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 ==
Die Dokumentation der STM32 ist im Vergleich zur [[AVR]]-Familie umfangreicher und komplexer. Sie teilt sich in mehrere Dokumente auf.
Als Beispiel der Dokumentation soll stellvertretend der [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1031/LN1565/PF164486 STM32F103RC] genannt werden. Die Seite von ST beinhaltet alle nötigen Informationen passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Im [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/datasheet/CD00191185.pdf STM32F103xC/D/E Datasheet] sind die speziellen Eigenschaften einer bestimmten Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt, sowie die Zuordnung Chipname - Flash/RAM-Größe. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben.
* Im [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/reference_manual/CD00171190.pdf Reference Manual (RM0008)] sind alle Peripheriemodule der jeweiligen STM32-Controllerfamilie im Detail beschrieben.
* Das [http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0403c/index.html ARMv7M Architecture Reference Manual] beschreibt detailliert den Prozessorkern, wie das Exception Model, die CPU Instruktionen inklusive Encoding, etc.
* Das [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/CD00228163.pdf STM32 Cortex-M3 Programming Manual] ist eine Zusammenfassung des ARMv7M Architecture Reference Manual bezogen auf die STM32.
* Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/programming_manual/CD00283419.pdf Flash Programming Manual] für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Zusätzlich sollten auch die [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/errata_sheet/CD00197763.pdf Errata Sheets] beachtet werden. Empfohlen sei auch die Appnote "[http://www.st.com/web/en/resource/technical/document/application_note/CD00164185.pdf AN2586 Getting started with STM32F10xxx hardware development]".
Die jeweiligen Dokumentations-PDFs sind auf der Produktseite von ST eines jeden Mikrocontrollers verlinkt.

== Hardware Zugriffs-Libraries ==
=== CMSIS ===

Die CMSIS (ARM® '''C'''ortex™ '''M'''icrocontroller '''S'''oftware '''I'''nterface '''S'''tandard) ist eine Library von ARM für den Zugriff auf die herstellerübergreifenden Funktionen des ARM-Cores. Hierzu gehört bei den Cortex-M4F-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 ‎STM32 Standard Peripheral Library enthalten. Die Compiler-Hersteller liefern eine jeweils zur ihrer Tool-Version passende bzw. geprüfte Library (incl. CMSIS) aus. Diese Libs können, gegenüber den Downloads beim Chip-Hersteller, auch ältere Version beinhalten.

=== ‎STM32 Standard Peripheral Library ===

ST bietet für jede Controller-Familie eine umfangreiche zur CMSIS passende Peripherie-Bibliothek. Alle Funktionen um die Peripherie zu benutzen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherie-Register 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. Die Library beinhaltet außerdem für fast jede Peripherie mehrere Beispiele.
Für die USB Schnittstelle gibt es noch eine extra Library, genauso wie für Ethernet.

Auf der "Design Resources" Seite der Produktseite von ST eines jeden STM32 Mikrocontrollers kann die Library für den jeweiligen Controller heruntergeladen werden, z.B. [http://www.st.com/web/en/catalog/tools/PF257890 hier für den o.g. STM32F103RC].

Library für STM32F4xx: [http://www.st.com/web/en/catalog/tools/PF257901# STSW-STM32065 STM32F4 DSP and standard peripherals library]

=== ‎STM32Cube / HAL ===

Wird in Zukunft die Standard Library ablösen.
* http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/LN1897

== Programmierung ==
Zur Programmierung der STM32 gibt es verschiedene Möglichkeiten, sowohl kommerzielle proprietäre als auch mit Freier Software.

Der GCC (in seinen verschiedenen Binärdistributionen) ist der einzige ARM Compiler der [http://de.wikipedia.org/wiki/C%2B%2B11 C++11] unterstützt.

=== Freie Software/Freeware ===
==== Selber zusammenstellen ====
Man nehme...:
* Eine Entwicklungsumgebung nach Wahl:
** [http://www.eclipse.org Eclipse] mit [http://www.eclipse.org/cdt/ C/C++ Development Tooling] und [http://gnuarmeclipse.livius.net/blog/ GNU ARM Plug-in] (Bei Verwendung vom GCC-ARM-Embedded als Toolchain "Sourcery G++ Lite" auswählen, dieser sieht für eclipse gleich aus) (Linux, Windows)
** [http://netbeans.org/ Netbeans] mit [http://plugins.netbeans.org/plugin/37426/gdbserver GDBserver-Plugin] (Linux, Windows)
** [http://www.kdevelop.org/ KDevelop] (Linux)
** [http://www.geany.org/ Geany] (Linux, Windows)
** Oder ein einfacher Texteditor
* Einen C,C++ Compiler:
** Eine der [[ARM_GCC#GCC_Bin.C3.A4rdistributionen|GCC-Binärdistributionen]], siehe auch [[#GCC|GCC]] (je nach Distribution Linux, Windows)
* Programmiersoftware zum Flashen des Target:
** [http://openocd.sourceforge.net/ OpenOCD] unterstützt viele Debug/Programmier-Adapter (Linux, Windows)
** [https://github.com/texane/stlink Texane stlink] funktioniert gut mit den ST-Link Adaptern wie sie zB. auf den STM32 Discovery Boards zu finden sind (Linux)
** Turtelizer2 oder andere JTAG Programmieradapter
** Bei Verwendung eines Segger J-Link, den [http://www.segger.com/admin/uploads/productDocs/UM08005_JLinkGDBServer.pdf Segger GDB-Server] in Verbindung mit dem beim GCC mitgelieferten GDB (Linux, Windows).

==== Komplette IDE's ====
* [https://developer.mbed.org/platforms ARM mbed Developer Site] ist der ultimative Compiler für denjenigen, der nur mal schnüffeln will. Doppelklick of das gewünschte Board, Beispielprogramm (rechts am Rand auswählen), kompilieren und über USB hochladen. Schon blinkt es! Wermutstropfen: mbed läuft nicht lokal, nur im WWW.
* [http://www.codesourcery.com/sgpp/lite_edition.html Codesourcery Lite Edition] Mit dieser Umgebung muss man sich anfreunden können, was mir bisher nicht gelungen ist. Es sind nur wenig Beispielprojekte verfügbar. Nicht mehr kostenlos verfügbar.
* [http://www.coocox.org/ Coocox Eclipse IDE] kostenlose IDE für STM32F0/F1/F2/F3/F4. Basiert auf der ARM-GCC Toolchain und es gibt eine breite Unterstützung. Es ist sogar ein freies RTOS verfügbar. Beim Start der IDE muss man geduldig sein, was jedoch für alle Eclipse basierten IDE's gilt. Eine gute Wahl ohne Limits mit breiter Debugger-Unterstützung. 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, Artikel: [[STM32 CooCox Installation]]
* [http://emide.org/ emIDE] kostenlose IDE von Segger. Die emIDE basiert auf Code::Blocks. Sie ist auf ARM-GCC aufgebaut und unterstützt eine große Zahl an unterschiedlichen JTAG/SWD Debugger - natürlich auch den J-Link aus gleichem Hause.
* [http://www.emblocks.org EmBlocks] kostenlose IDE, Code::Blocks basiert, unterstützt STM32 L1/F0/F1/F2/F3/F4/W, integrierter Compiler (ARM-GCC), integrierter GDB-Debugger, Jlink/ST-Link, System view (Peripherie Register anzeigen) beim Debuggen, Project Wizard (Eigene Wizards können mit Squirrel geschrieben werden), Basiert auf Code::Blocks und gefällt mir recht gut da man ihn fast so gut nutzen kann wie die µVision von Keil, jedoch ohne deren Limit, http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks STM32 - Einstieg mit Em::Blocks]
** heisst jetzt EmBitz beta 0.42 -> http://www.emblocks.org/web/downloads-main
* [http://cms.seng.de/service-support/downloads/ Entwicklungsumgebung GNU/Linux] für STM32F1 mit OpenOCD und Olimex ARM-USB-OCD-H, Bedienung über Eclipse IDE oder Kommandozeile.
* [http://www.openstm32.org/blog1-System-Workbench-for-STM32 System Workbench for STM32] (SW4STM32) ist eine uneingeschränkte und kostenlose IDE. Sie wird von [http://www.st.com/web/en/catalog/tools/FM147/CL1794/SC961/SS1533/PF261797 ST] offiziell unterstützt. Die Entwicklungsumgebung ist in der Version 1.0 seit 5.2.2015 erhältlich. Seit Februar 2016 ist eine Version für Linux verfügbar.

==== Andere Programmiersprachen ====

* [http://mecrisp.sourceforge.net Mecrisp-Stellaris], eine native Forth-Implementation für ARM Cortex M0/M3/M4. Es werden bereits mehrere STM32 Targets unterstützt und neue Portierungen sind herzlich willkommen. Auch Chips von TI, NXP und Freescale sind im aktuellen Paket enthalten.

=== Kommerzielle Umgebungen ===

* [http://www.keil.com/arm/mdk.asp Keil µVision] (Demo max. 32KB Code/Free für STM32F0/STM32L0): 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. In Verbindung mit einem ULINK2 ist die Umgebung schon sehr einfach zu bedienen - leider ist der Compiler mit großen Abstand der langsamste den ich je nutzte da er keine parallel Option wie der GNU-CC besitzt. Mit der µVision lässt sich kein fremdes File in den Controller in den Flashspeicher des Controllers schreiben. Für den Anfänger eine gute Wahl. Der Preis ist jedoch ein guter Grund auf andere freie IDE's zu wechseln. µVison selbst kann kostenlos mit dem MDK-Evaluationkit heruntergeladen werden. [https://www.keil.com/arm/demo/eval/arm.htm#DOWNLOAD download] Wer sich nur auf STM32 Cortex M0/L0 beschränkt kann die Keil MDK auch ohne 32K Begrenzung frei nutzen. [http://www2.keil.com/stmicroelectronics-stm32/mdk download]
* [http://www.iar.com/en/Products/IAR-Embedded-Workbench/ IAR-Embedded-Workbench] (Demo max. 32KB Code) [http://supp.iar.com/Download/SW/?item=EWARM-EVAL download]
* [http://www.isystem.com/download/winideaopen winIDEAOpen] Keine Code Limitierung, GCC und Testwerkzeug beinhaltet. Läuft mit dem iTag50 Adapter, Segger J-Link und dem ST-Link
* [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.rowley.co.uk/arm/ Rowley Crossworks] (Demo 30 Tage unbeschränkt, 150$ für nichtkommerzielle Nutzung, auf GCC basierend). Mir ist nicht klar warum man für diese IDE Geld bezahlen soll. Der GNU-Compiler ist frei und die Entwicklungsumgebungen die auf Eclipse basieren, ebenfalls. Allerdings ist diese Einstellungsarbeit schon was für den etwas erfahrenen Entwickler.
* [http://www.code-red-tech.com Code Red] (GCC basierend)
* [http://www.sisy.de/index.php?id=17&no_cache=1 SiSy ARM oder SiSy Micrcontroller++] (Demo verfügbar keine Gößenbegrenzung, basiert auf GNU-Compiler, grafische Programmierung mit UML möglich, integrierter Debugger)
* [http://www.comsytec.eu/epsdebugger.php EPS Debugger Plugin, für STM32 Development mit Code::Blocks]
* [http://www.mikroe.com MikroE bietet neben Pascal und Basic auch C mit kompletter Oberfläche mit Compiler etc. pp relativ günstig]

=== STM32CubeMX ===
Dies ist eine Software von ST selbst, die die Auswahl und Konfiguration von STM32-Mikrocontrollern vereinfacht:
* Auswahl der Controller oder Entwicklungsboards mit einer parametrischen Suche
* grafische Konfiguration der Pins und Alternate Functions (inkl. Überprüfung auf Kollisionen - bei Entwicklungsboards sind gewisse Pins schon vorkonfiguriert und werden angezeigt)
* grafische Konfiguration des Clock-Trees
* Generierung von C-Code entsprechend der grafischen Konfiguration. Dieser funktioniert nur mit den neuen STM32CubeFx Libraries, nicht mit den alten Standard Peripheral Libraries.
* Simulation des Strom-Verbrauchs unter Auswahl verschiedenster Stromquellen und Batterien
Die Software kann [http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/PF259242 bei ST heruntergeladen] werden. Sie wird im Windows Executable Format angeboten und erweckt daher den Eindruck, ausschließlich für Windows geeignet zu sein, ist aber tatsächlich Java-basiert und daher betriebssystem-unabhängig.
==== STM32CubeMX unter Linux ====
Ab der Version 4.13 liegt jetzt ein Linux-Installer mit bei.

Unter Linux kann STM32CubeMX installiert werden, indem man das heruntergeladene .zip-Archiv entpackt, und den enthaltenen Installer per Java über ein Terminal startet:
<pre>java -jar SetupSTM32CubeMX-4.5.0.exe</pre>
Das Anlegen der Desktop/Startmenü-Shortcuts funktioniert unter Linux nicht richtig und kann daher deaktiviert werden. Um STM32CubeMX nach der Installation zu starten, wechselt man im Terminal in den Installationsort und gibt ein:
<pre>java -jar STM32CubeMX.exe</pre>
Damit das funktioniert, muss die Oracle Java Runtime Environment 1.8 installiert sein (Siehe z.B. [http://wiki.ubuntuusers.de/Java/Installation/Oracle_Java/Java_8#Java-8-JRE hier] für Ubuntu). Nicht benötigt wird wine.

=== Tutorials für diverse Tool-Kombinationen ===
* [[STM32 Eclipse Installation|Windows,Linux, Eclipse + Yagarto/CodeSourcery + OpenOCD/ST-Link]]
* [[STM32 Eclipse JLink Linux/Windows|Windows,Linux, Eclipse + GCC-ARM-Embedded + JLink]]
* [[Linux auf STM32|Linux auf STM32 (ucLinux)]]

* Windows
** Eclipse
*** [http://www.mikrocontroller.net/topic/216554 Windows, Eclipse, codesourcery, st-link ]
*** [http://www.firefly-power.de/ARM/debugging.html Eclipse Plugin "GDB Hardware Debugging" mit OpenOCD]
** Code::Blocks
*** [http://www.mikrocontroller.net/topic/265600 Windows, Code::Blocks, STM32F4]
** STM32 mit EmBlocks
*** [http://www.emblocks.org/web/downloads-main Download EmBlocks]
*** [https://www.youtube.com/watch?v=coHPJylnzC8 Video STM32 Project Wizzard in EmBlocks]
** Atollic TrueSTUDIO
*** [[STM32 LEDBlinken AtollicTrueStudio|Atollic TrueSTUDIO Installation + Demo]]
** MDK-ARM Lite mit Einstellungen für 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]
** SiSy ARM, STM32
*** Download: [http://www.sisy.de/index.php?id=59 SiSy DEMO] kein Begrenzung der Codegröße
*** [http://www.youtube.com/watch?v=84Y3jYLWYpo Videobeispiel]
** Microsoft Visual Studio
*** [http://visualgdb.com/tutorials/arm/stm32/f4_discovery/ "STM32F4-Discovery tutorial with Visual Studio"]
* Ubuntu
** [http://cms.seng.de/service-support/downloads/ Installing a toolchain for Cortex-M3/STM32 on GNU/Linux] - How-to manual, für STM32F1 unter GNU/Linux mit OpenOCD und Olimex ARM-USB-OCD-H. Integrierte Make files, Linker Skripte, Startup-Code, diverse Tools und Demo-Projekt/Programm. Einbindung in Eclipse IDE oder Bedienung über Kommandozeile.
** [http://fun-tech.se/stm32/index.php Ubuntu, Selbstcompilierter GCC, STM32/Cortex-M3]
** [http://thetoolchain.com The ToolChain] - Automatisch installierende Entwicklungsumgebung mit eigenen und externen Treibern, Unterstützt QtCreator als IDE, Flexibel erweiterbar über Shellskripte

* [http://www.mikrocontroller.net/topic/214719 Tipps für Installation mit Eclipse]

===Programmieradapter===
* [http://www.segger.com/jlink-model-overview.html SEGGER J-LINK / J-TRACE] für u.a. alle ARM7/9/11, Cortex-M0/M1/M3/M4/A5/A8/A9/R4 als [http://www.segger.com/cms/j-link-edu.html Non-Commercial] J-LINK-EDU für ca. 50,- zu haben, läuft in µVision, IAR, GDB (Linux & Windows über einen eigenen [http://www.segger.com/admin/uploads/productDocs/UM08005_JLinkGDBServer.pdf GDB-Server]), Keil, ... Der J-Link ist mit Abstand der schnellste Debugger den ich bisher testen konnte. Wer es beim Debuggen eilig hat, ist mit dem J-Link von Segger auf den besten Seite.
* Keil [http://www.keil.com/ulinkme/ ULINK-ME], [http://www.keil.com/arm/ulink2/ ULINK2], [http://www.keil.com/arm/ulinkpro/ ULINK pro] Wenn man die die µVision IDE nicht verlassen mag, kann man sich mit diesen Adaptern anfreunden denn sie arbeiten nur mit dieser IDE zusammen. Sie benötigen keine USB-Treiber denn sie nutzen geschickt das HID-Device des Betriebssystems. Es lässt sich kein fremdes Binary oder Hex-File flashen. Der ULINK2 kostet genau soviel wie ein Segger J-Link Basic bei gleichem Funktionsumfang. Dieser lässt sich aber auch in Verbindung mit anderen IDE's (GDB, usw) einsetzten.
* [http://www.st.com/internet/evalboard/product/219866.jsp ST-LINK], [http://www.st.com/internet/evalboard/product/251168.jsp ST-LINK/V2]
* 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). Diese ist jedoch mit 1.8Mhz Takt ein sehr langsamer Vertreter seiner Art. Mit ihm lässt sich jedoch sowohl Debuggen als auch Flashen von fremden Hex- und Binary-Files. Er unterstützt aber nur MCU's von ST. NXP, Atmel oder TI lassen sich damit nicht programmieren. Der Discovery-JTAG beherrscht nur SWD, kein JTAG und hat keine Treiber, die den Programmierprozessor vom Zielsystem elektrisch entkoppelt. Der ST-Link in der Adapterversion hat diese Nachteile nicht und kostet auch nur um 20 €.
* [http://www.raisonance.com/~rlink-debugger-programmer__microcontrollers__tool~tool__T018:4cn9ziz4bnx6.html Raisonance RLink]
* [http://www.amontec.com Amontec] (Achtung: keine Reaktion auf Bestellung, Telefon, Email...)
* [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)

In der Regel haben die [[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]]. Die Discovery-Boards haben keinen separaten JTAG-Stecker, aber zumindest für das STM32F4 Discovery kann man sich leicht einen Adapter Pinheader->JTAG Stecker selber bauen.

Andere [[JTAG]] Adapter wie z.B. der ULink2 von Keil funktionieren nur mit dem Keil Compiler. Leider kann dieser auch kein fremdes Binary oder Hex-File in den Controller schreiben.

===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]
* [https://www.olimex.com/Products/ARM/JTAG/ Olimex] ARM-USB-OCD (ca. 60.-, hat zusätzlich einen Spannungsausgen und einen COM Port)
* [http://www.oocdlink.com/ OOCDLink] [_Link ist derzeit nicht verfügbar_]
* [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 dass man einen JTAG-Adapter benötigt. Dies erfordert ggf. entsprechende Konfiguration über die BOOTx-Pins und/oder die Option-Bytes, und ein Programm wie [https://code.google.com/p/stm32flash/ stm32flash].

=== Demo-Projekte ===

* Einführung in die GPIO Programmierung der STM32F10x und STM32F30x Prozessoren am Beispiel des STM32F3 Discovery Boards und Vergleich zur AVR IO Registerstruktur [http://www.mikrocontroller.net/topic/300472#new]
* [[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
* [http://mikrocontroller.bplaced.net/wordpress/?page_id=744 Uwe Becker's Libraries für den STM32F4]
* [http://mikrocontroller.bplaced.net/wordpress/?page_id=3290 Uwe Becker's STM32F429 Discovery Board Oszilloskop], hier der [http://www.mikrocontroller.net/topic/319831#new Thread]
* [http://mikrocontroller.bplaced.net/wordpress/?page_id=3424 Uwe Becker's STM32F429 Discovery Board ZX-Spectrum Emulator]

== 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, Ausstattung).
* 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.]

== 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)
* [[#Bootmodi|Boot-Pins]]

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.

=== Bootmodi ===
Unterschiedliche Bootmodi lassen sich mittels der PINs BOOT0 und BOOT1 auswählen . Siehe Application Note [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Attachments/18225/AN2606.pdf AN2606]. Außer F1 besitzen neuere Familien ein SYSCFG_MEMR Register. In dieses Register kann man die gewünschten Boot0/1 Werte schreiben und nach einem Core-Reset (!= System_Reset) startet der Prozessor im gewünschten Mode. Eine Neu- bzw. Deinitialisierung der Peripherie empfiehlt sich!

==== 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

Ab F2 gibt es auch ein SYSCFG_MEMRMR Register. Schreibt man hier den Wert für "System Flash" und macht einen Corereset (keinen Systemreset), so landet man auch im Bootloader, unabhängig vom Wert der Boot Pins.

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 (alle USB fähigen CPUs > F103)
* 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]

Tools für den Download über den STM32-Bootloader:
* [http://www.st.com/web/en/catalog/tools/PF257525 STSW-MCU005 STM32 and STM8 Flash loader demonstrator]
* [https://code.google.com/p/stm32flash/ stm32flash] - Open source flash program (RS-232)
* [http://dfu-util.sourceforge.net/ dfu-util] - Open source flash program (USB)

== Bewertung ==
=== 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.hitex.com/fileadmin/pdf/insiders-guides/stm32/isg-stm32-v18d-scr.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 $!

'''Vorteile gegenüber SAM3/4:'''

* Fast alle Pins sind 5-Volt tolerant.

'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* Schnelle direkte Offset-Adressierung ermöglicht effizienten Zugriff auf Stack-Variablen, lokal gespeicherte Flash-Konstanten, struct/Array-Elemente
* Einfache einheitliche Adressierung des gesamten Adressraums, d.h. Pointer auf Peripherieregister, RAM & Flash können exakt gleich behandelt werden, keinerlei Banking/Umschalt-Mechanismen erforderlich auch bei großem Flash/RAM
* Interrupt-Prioritäten und Prioritätsgruppen
* Effiziente Pointerarithmetik da Registerbreite=Adressbreite
* bessere Peripherie wie USB, Ethernet, Vielzahl an Timern
* der ARM-Core hat eine höhere Taktfrequenz und kann gleichzeitig mehr in weniger Takten berechnen
* Hardware-Division, bei einigen FPU zur effizienten float-Berechnung
* Mit größerem Flash/RAM verfügbar
* Code kann direkt aus dem RAM ausgeführt werden, Speicherschutz und privilegierter Ausführungsmodus können "Kernel"- vor "Anwendungs"-Code schützen, somit wird das dynamische Nachladen von Anwendungen aus externem Speicher effizient & sicher möglich
* ... und weitere 1000 Punkte ...

'''Links'''
* [http://www.arm.com/files/pdf/ARM_Microcontroller_Code_Size_%28full%29.pdf Code Size Analyse zwischen verschiedenen µC]

=== Nachteile ===

'''Nachteil gegenüber LPC1700:'''
* STM32F1xx: nur 72 MHz statt 100 MHz (LPC1759: 120 MHz) Taktfrequenz; STM32F2xx hat diesen Nachteil nicht (ebenfalls 120MHz, STM32F4xx mit 180MHz)
* 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 und STM32F4xx (2 Stück)
* I2S Einheit von ST hat keinen FIFO und im 24/32Bit Modus müssen 2x16Bit Halbwörter übertragen werden. Wobei allgemein bei neuen ARM Prozessoren die vorhandenen DMA-Kanäle (basierend auf eigenen BUS-Kanälen und Speicherzugriffen) FIFO in beliebiger Größe bedeutet. (Gilt nicht bei bestimmten STM32F4xx)

'''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. Von NXP gibt es Cortex-M0 µC im DIL Gehäuse.

* Viel Peripherie, Clocks müssen alle richtig eingestellt werden, ggf. Anpassung des Startup Codes usw.

'''

== Errata, Tipps und Tricks ==
=== Hardware ===
* 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 bei der F1 Serie 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/st-web-ui/static/active/en/resource/technical/document/errata_sheet/CD00238166.pdf STM32F105xx and STM32F107xx Errata sheet] ) zu finden sind. Workarounds hierzu finden sich in der Application Note [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/CD00209826.pdf AN2824]. Am Besten benutzt man jedoch die I2C Communication peripheral application library (CPAL) von ST ([http://www.st.com/web/catalog/tools/FM147/CL1794/SC961/SS1743/PF258336 STSW-STM32127])
* [http://blog.frankvh.com/category/stm32/ weitere undokumentierte Features]
* Interrupt-Flags in Statusregistern der diversen Peripherals wie der Timer müssen zu '''Beginn''' (bzw. möglichst weit vor dem Return) der ISR zurückgesetzt werden, da die ISR sonst eventuell 2x ausgeführt wird (Siehe [https://my.st.com/public/Faq/Lists/faqlst/DispForm.aspx?ID=143&level=1&objectid=141 STM32 FAQ] und [http://www.mikrocontroller.net/topic/312393#new Forum]).

=== Software ===
==== GCC ====
Um den GCC direkt zu verwenden (zB. mit selbstgebautem makefile), falls man das nicht von einer Entwicklungsumgebung machen lässt, siehe zunächst [[ARM GCC]]. STM32-spezifisches ist:
* Wird die [[#.E2.80.8ESTM32_Standard_Peripheral_Library|STM32 Standard Peripheral Library]] und ein Quarz verwendet, so muss noch per Präprozessor-Definition die Frequenz des Quarzes angegeben werden mittels z.B. -DHSE_VALUE=8000000 für 8MHz (wie auf dem STM32F4 Discovery).

===== Startupcode & Linkerscript =====
* Damit der compilierte Code an den richtigen Stellen im Controller landet (d.h. dem Flash) muss man dem Linker ein Linkerscript mitgeben. Dies geht per "-T ''pfad_zum_linkerscript.ld''" an den Linker-Befehl. Im Archiv der [[#.E2.80.8ESTM32_Standard_Peripheral_Library|STM32 Standard Peripheral Library]] befindet sich ein Beispiel-Linkerscript für die Atollic TrueSTUDIO IDE, dieses kann direkt mit dem GCC verwendet werden. Beispielsweise für den STM32F4 befindet sich das Script im Pfad "/STM32F4xx_DSP_StdPeriph_Lib_V1.1.0/Project/STM32F4xx_StdPeriph_Templates/TrueSTUDIO/STM324x7I_EVAL/stm32_flash.ld" des Archives.
* Damit beim Starten die richtigen Initialisierungen vorgenommen werden (wie globale Variablen und bei C++ Konstruktoren globaler Objekt-Instanzen) muss als erstes ein Startupcode laufen, der dann die main()-Funktion aufruft. Der Startupcode ist meistens in Assembler geschrieben, C-Code ist aber auch möglich. Im Archiv der [[#.E2.80.8ESTM32_Standard_Peripheral_Library|STM32 Standard Peripheral Library]] befindet sich ein Beispiel-Startupcode für die Atollic TrueSTUDIO IDE, dieser kann direkt mit dem GCC verwendet werden. Beispielsweise für den STM32F4 befindet sich der Code in Assemblerform im Pfad "/STM32F4xx_DSP_StdPeriph_Lib_V1.1.0/Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f40xx.s" des Archives. Der Assemblercode kann per arm-none-eabi-as (Flags s.o.) assembliert werden, die resultierende .o -Datei normal mitgelinkt.

Zusammen bieten die beiden Dateien der Anwendung ein Standard-C-Interface, d.h. man kann wie gewohnt globale Variablen verwenden und seinen Code in die main()-Funktion schreiben.

=== 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]

=== 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
* [http://www.efton.sk/STM32/STM32F4xx_doc_errors.txt Liste von Dokumentations-Fehlern]

== Bezugsquellen ==

=== Controller ===

Versand Europaweit im endasmedia.ch Shop
* STM32F105 Controller für 2.50€ [http://shop.endasmedia.ch/index.php?id_product=8&controller=product&id_lang=1 shop.endasmedia.ch]

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]
* [http://de.rs-online.com/web/c/halbleiter/prozessoren-und-mikrocontroller/mikrocontroller/?sort-by=default&sort-order=default&applied-dimensions=4294417325&lastAttributeSelectedBlock=4294425895 RS-Online]

Gewerblich liefern natürlich viele wie EBV, [http://de.futureelectronics.com Future Electronics], Mouser, Farnell, Digikey usw...

=== Evaluation Boards ===
* Siehe [[:Kategorie:ARM-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.conrad.de/ce/de/product/443910/ STM32F4 Discovery Kit bei Conrad] 17,11 €
* [http://www.ST.com/stm32l152c-discovery STM32 L1 Discovery] mit kleiner LCD-Anzeige; [http://www.ST.com/web/en/catalog/tools/PF250990 Weitere Informationen dazu]
* [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/boards/cortexm.asp Keil/ARM Demoboards]
* [http://www.phytec.de Phytec]
* [http://shop.myavr.de/index.php?sp=artlist_kat.sp.php&katID=37 verschiedene ARM Produkte und Erweiterungen bei myAVR]
* [http://re.reworld.eu/de/produkte/s64dil-405/index.htm S64DIL-405 STM32Fxxx ARM Cortex M3 Mikrocontrollermodul mit USB-Schnittstelle, Steckbretttauglich] (Leerplatine eignet sich auch für STM32F1xx Prozessoren.)
* [http://www.amazon.de/STM32F4-DISCOVERY-STM32F429-Cortex-M4-Development/dp/B00HGG0KHY STM32F429 DISCOVERY Cortex M4 mit 2,4" Touch-TFT, 3-Achs Sensor, 64 MBit SDRAM ab ~25 EUR bei Amazon, Ebay u.a.]

== Weblinks, Foren, Communities, Tutorials ==
* [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks STM32 - Einstieg mit Em::Blocks Tutorial]
* [http://www.mikrocontroller.net/topic/173753 Diskussion zum Artikel]
* [http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex* Suche im Forum]
* [[STM32 für Einsteiger]]
* [[STM32 CooCox Installation]]
* [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 ]
* [http://mikrocontroller.bplaced.net STM32F4 Quellcode-Librarys und CooCox-Projekte in Deutsch ]
* [http://myugl.de Tutorial für Grafik-Librarys und SiSy-Projekte in Deutsch ]
* [http://www.st.com/web/en/catalog/tools/FM147/CL1794/SC961/SS1533/PF251717 MicroXplorer MCU graphical configuration tool ]
* [http://www.harerod.de/CoreMark_STM32.pdf Testbericht über CoreMark 1.0 auf Cortex-M3/M4 mit verschiedenen Compiler- und MCU-Einstellungen]
* [http://klaus4.blogspot.com/2014/05/stm32f4-discovery-mit-opensource.html STM32-Toolchain mit Eclipse CDT 4.3, GnuArmEclipse, OpenOCD 0.8.0, Gnu Arm GCC 4.8, STM32CubeMX]

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

ARM Cortex Mikrocontroller

2016-02-03T11:10:17Z

Kichi: /* Compiler & Software (alphabetisch) sortiert */

Die Firma ARM stellt selbst keine Prozessoren/Controller her, sondern entwickelt nur sogenannte "IP-Cores", die von Herstellern wie Atmel, Infineon, ST, NXP, TI und vielen anderen lizenziert werden. Diese Hersteller ergänzen den Core um Speicher und Peripherie. Der Vorteil dieses Modells ist, dass dadurch sehr viele Prozessoren mit unterschiedlichster Ausstattung verfügbar sind, die alle mit dem selben Befehlssatz (und damit dem selben Compiler) programmierbar sind.

Allen ARM-Cores gemeinsam ist die 32 Bit RISC-Architektur. Für diese gibt es den klassischen 32bit ARM Befehlssatz und den zusätzlichen, kleineren 16/32 Bit '''Thumb'''-Befehlssatz. Die verschiedenen Prozessoren/Controller unterstützen einen oder beide davon. Thumb-fähige Controller sind erkennbar am '''T''' in der Bezeichnung, z. B. ARM7'''T'''DMI. Thumb kodiert die meisten Instruktionen in 16bit, den Rest in 32bit, was in einem kleineren Prozessor und geringenem Platzbedarf des Codes resultiert [http://www.arm.com/files/pdf/ARM_Microcontroller_Code_Size_%28full%29.pdf]; der Nachteil ist die etwas niedrigere Geschwindigkeit. Die Cortex-M Kerne unterstützen ausschließlich den Thumb2-Befehlssatz.

Seit einigen Jahren sind ARM-basierte Mikrocontroller erhältlich, die aufgrund der vergleichbar einfachen Beschaltung und niedrigem Stromverbrauch eine echte Alternative zu 8-Bit-Controllern wie dem [[AVR]] darstellen. Die ersten Controller mit diesen Eigenschaften verwendeten den ARM7TDMI-Kern (zB. LPC2000) (ARMv4T-Architektur). Mittlerweile wurden diese vom Cortex M-Kern abgelöst (ARMv6M, ARMv7M-Architektur), welcher in verschiedenen Varianten für verschiedene Einsatzzwecke verfügbar ist.

'''In diesem Artikel geht es primär um die ARM Cortex-M Mikrocontroller, weniger um ARM [[Cortex-A]] Prozessoren, welche in Smartphones, [[Raspberry Pi]] u.ä. eingesetzt werden.'''

Es gibt folgende Varianten des Cortex-M Mikrocontroller-Kerns, aufgeführt vom energieeffizientesten zum leistungsfähigsten.

== ARM Cortex M0/M0+ ==
Als günstigste und energieeffizienteste Variante gibt es die Cortex-M0 Cores mit deutlich kleinerem Befehlssatz als z.B. Cortex-M3. Diese
werden beispielsweise in folgenden Controllern eingesetzt:

* [http://www.st.com/internet/mcu/subclass/1588.jsp?WT.ac=fp_may12_stm32f0 STM32F0] von [http://www.st.com STMicro], siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://ics.nxp.com/products/lpc1000/lpc11xx/ LPC11xx] von [http://www.nxp.com NXP], siehe '''[[LPC1xxx|LPC1xxx hier im Wiki]]'''
* [http://www.infineon.com/XMC1000 XMC1000] von [http://www.infineon.com Infineon], siehe '''[[XMCxxxx|XMCxxxx hier im Wiki]]'''
* [http://www.nuvoton.com/NuvotonMOSS/Community/ProductInfo.aspx?tp_GUID=5dbf7d7a-b6df-4fe1-91c9-063449500ce7 NuMicro-Controller] von Nuvoton (ex Winbond), laut Datenblatt mit 2.5-5.5V Betriebsspannung!
* [http://www.cypress.com/PSOC4 PSOC4 Familie] von [http://www.cypress.com Cypress]
Für die M0-Familie ist für den LPC1xxx bereits eine '''[http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx#Allgemeine_Informationen_zum_Aufbau_der_Code_Base Code-Base]''' und ein preisgünstiges '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso Entwicklungskit]''' vorhanden.

Inzwischen gibt es auch eine optimierte Version des Cortex-M0 - die Cortex-M0+ Cores. Diese können (optional) einige Features der Cortex-M3 Serie beinhalten, wie z.B eine MPU:

* [http://www.silabs.com/products/mcu/32-bit/efm32-zero-gecko/pages/efm32-zero-gecko.aspx EFM32 Zero Gecko] und [http://www.silabs.com/products/mcu/32-bit/efm32-happy-gecko/pages/efm32-happy-gecko.aspx EFM32 Happy Gecko] von [http://www.silabs.com Silicon Labs], siehe '''[[EFM32|EFM32 hier im Wiki]]'''
* [http://www.nxp.com/products/microcontrollers/cortex_m0plus/lpc800/ LPC8xx] von [http://www.nxp.com NXP]
* [http://www.freescale.com/webapp/sps/site/taxonomy.jsp?code=KINETIS_L_SERIES Kinetis L-Serie] und [http://www.freescale.com/webapp/sps/site/taxonomy.jsp?code=KINETIS_M_SERIES Kinetis M-Serie] von [http://www.freescale.com/ Freescale]
* [http://www.fujitsu-fm-family.com/products/fm0.html angekündigte FM0+ Familie] von [http://www.fujitsu.com/emea/services/microelectronics Fujitsu]
* [http://www.st.com/web/en/catalog/mmc/FM141/SC1169/SS1817?icmp=ss1817_pron_pr_feb2014 angekündigte M0+ Familie] von [http://st.com STMicroelectronics]
* [http://www.atmel.com/Microsite/samd/default.aspx?utm_campaign=February_2014_Newsletter.html&utm_medium=email&utm_source=Eloqua SAM D Familie] von [http://atmel.com Atmel]
* [http://www.cypress.com/PSOC4 PSOC4 Familie] von [http://www.cypress.com Cypress]

== ARM Cortex M3 ==
Der erste Kern der Cortex M-Reihe war der Cortex-M3. Dieser ist vom Leistungsniveau her am ehesten mit seinem Vorgänger, dem ARM7TDMI vergleichbar.

Controllerfamilien dieser Klasse sind:

* [http://www.silabs.com/products/mcu/32-bit/efm32-tiny-gecko/pages/efm32-tiny-gecko.aspx EFM32 Tiny Gecko], [http://www.silabs.com/products/mcu/32-bit/efm32-gecko/pages/efm32-gecko.aspx EFM32 Gecko], [http://www.silabs.com/products/mcu/32-bit/efm32-leopard-gecko/pages/efm32-leopard-gecko.aspx EFM32 Leopard Gecko] sowie [http://www.silabs.com/products/mcu/32-bit/efm32-giant-gecko/pages/efm32-giant-gecko.aspx EFM32 Giant Gecko] von [http://www.silabs.com Silicon Labs] , siehe '''[[EFM32|EFM32 hier im Wiki]]'''
* [http://www.nxp.com LPC13xx/LPC17xx/LPC18xx] von NXP oder die inzwischen schon sehr ausführliche, siehe '''[[LPC1xxx|LPC1xxx hier im Wiki]]'''
* [http://www.ti.com/lsds/ti/microcontroller/tiva_arm_cortex/c_series/tm4c_arm_cortex-m4/overview.page TIVA] von [http://www.ti.com Texas Instruments] (vormals Stellaris, vormals Luminary Micro)
* [http://www.atmel.com/products/at91/sam3landing.asp?family_id=605 AT91SAM3] von Atmel
* [http://www.st.com/internet/mcu/family/141.jsp STM32] Baureihen [http://www.st.com/internet/mcu/subclass/1169.jsp F1]/[http://www.st.com/internet/mcu/subclass/1520.jsp F2]/[http://www.st.com/internet/mcu/subclass/1376.jsp L1]/[http://www.st.com/internet/mcu/subclass/1377.jsp W] von STMicroelectronics , siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://www.toshiba-components.com/microcontroller/TMPM330.html TMPM330] von Toshiba
* [http://www.spansion.com/Products/microcontrollers/32-bit-ARM-Core/fm3/Pages/FM3-family.aspx FM3] von [http://www.spansion.com Spansion] (vormals Fujitsu)
* [http://www.holtek.com.tw/english/products/32bit_flashmcu.htm HT32] von Holtek Semiconductor
* [http://www.cypress.com/PSOC5 PSOC5] von Cypress

Für den LPC1xxx ist bereits eine '''[http://www.mikrocontroller.net/articles/Codebase_f%C3%BCr_LPC1xxx#Allgemeine_Informationen_zum_Aufbau_der_Code_Base Code-Base]''' und ein preisgünstiges '''[[LPC1xxx_Entwicklungskit_LPCXpresso]]''' vorhanden.

== ARM Cortex M4 ==
Als hoch performante Variante gibt es dann noch die Cortex-M4 Cores welche mit zusätzlichen [[DSP]]-Funktionen und teilweise einer (single precision) FPU ausgestattet sind.

Diese werden beispielsweise in folgenden Controllern eingesetzt:
* [http://www.freescale.com/webapp/sps/site/overview.jsp?code=ARM Kinetis Series] von Freescale
* [http://www.silabs.com/products/mcu/32-bit/efm32-wonder-gecko/pages/efm32-wonder-gecko.aspx EFM32-Wonder Gecko] von [http://www.silabs.com Silicon Labs], siehe '''[[EFM32|EFM32 hier im Wiki]]'''
* [http://www.nxp.com LPC43xx] von NXP (Dual Core)
* [http://www.st.com/internet/mcu/subclass/1605.jsp STM32F3] von [http://www.st.com STMicro], siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://www.st.com/internet/mcu/subclass/1521.jsp?WT.ac=p2_bn_jun12_stm32f4series STM32F4] von [http://www.st.com STMicro], siehe '''[[STM32|STM32 hier im Wiki]]'''
* [http://www.ti.com/lsds/ti/microcontroller/tiva_arm_cortex/c_series/tm4c_arm_cortex-m4/overview.page Tiva C Series, TM4C] von [http://www.ti.com Texas Instruments]. Früher nannte Texas Instruments diese Controller ''Stellaris LM4F Series''. 2013 begann TI mit einer große Umbenennung, bei der sogar neue Typenbezeichnung vergeben wurden. So wurde zum Beispiel aus dem LM4F230H5QR der TM4C123GH6PM. Gleichzeitig begann TI die Bezeichnung ''Stellaris'' aus Datenblättern, Software-Bibliotheken und Ähnlichem zu entfernen und durch ''Tiva'' zu ersetzen. Siehe auch [http://www.ti.com/lit/an/spma050a/spma050a.pdf].
* [http://www.infineon.com/XMC4000 XMC4000] von [http://www.infineon.com Infineon], siehe '''[[XMCxxxx|XMCxxxx hier im Wiki]]''', [[XMC4500|Artikel zum XMC4500]]
* [http://www.spansion.com/Products/microcontrollers/32-bit-ARM-Core/fm4/Pages/default.aspx FM4] von [http://www.spansion.com Spansion] (vormals Fujitsu)
* [http://www.atmel.com/products/at91/sam4landing.asp?family_id=605 AT91SAM4] von Atmel

== ARM Cortex M7 ==

Die neueste Variante der Cortex M-Reihe ist der M7, bei dem gegenüber dem M4 zahlreiche Features hinzukommen die die Brücke zu Anwendungsprozessoren schlagen: eine double precision-FPU, Code- und Daten-Cache, eine 6-stufige Pipeline mit Sprungvorhersage, und unterm Strich eine deutlich höhere Rechenleistung. Controller basierend auf dem Cortex M7 wurden u.a. von Atmel und ST angekündigt, sind aber noch nicht in Stückzahlen erhältlich. Der Cortex M7-Kern wird bereits von GCC unterstützt [https://launchpad.net/gcc-arm-embedded/+announcement/12983].

* [http://www.atmel.com/about/news/release.aspx?reference=tcm:26-63538 Pressemeldung von Atmel]
* [http://www.st.com/web/en/catalog/mmc/SC1169/SS1858 Produktseite der STM32F7-Serie von ST]

== ARM7TDMI ==
Der Vorgänger der Cortex-M-Cores ist der '''ARM7'''TDMI. Controllerfamilien dieser Klasse sind immer noch weit verbreitet:
* NXP (ehemals Philips) [[LPC2000]]
* Atmel [[AT91SAM]]7
* Analog Devices [[ADuC7xxx]]
* [http://focus.ti.com/mcu/docs/mcuprodoverview.tsp?sectionId=95&tabId=203&familyId=454 Texas Instruments TMS470]
* SAMSUNG S3C24x0 [http://www.samsung.com/global/business/semiconductor/productInfo.do?fmly_id=229&partnum=S3C2410]
* STR7xx von ST Microelectronics [http://www.st.com/mcu/inchtml-pages-str7.html]
* und viele weitere

Mehr Informationen zur ARM-Architektur finden sich in der [http://de.wikipedia.org/wiki/ARM-Architektur Wikipedia], weiterführende Links in der [[Linksammlung#ARM|Linksammlung]].

== Compiler & Software ==

=== [[ARM_GCC|GCC]] ===
Einer der beliebtesten Compiler für ARM-Prozessoren ist der GCC. Er kann sowohl ARM- als auch Thumb-Code erzeugen. Mehr dazu unter [[ARM GCC]].

=== C/C++ IDEs ===
Kostenlose Entwicklungsumgebungen (überwiegend GCC-basiert):
* [http://www.coocox.org/CooCox_CoIDE.htm CooCox IDE] (Eclipse basierend)
* [http://www.emblocks.org/web/ EmBlocks IDE] (Basiert auf Code::Blocks)
** Compiler: GNU ARM-GCC (in der Installation enthalten), RealView und IAR
** Hardware: STlink (mit "Live data"), openOCD, Jlink.
** Project Import: CoIDE, uVision, Atmel studio, MplabX, Mplab 8
** OS aware debugging
***FreeRTOS
***ChibiOS/RT
** Unterstützt sehr viele Controller(-Hersteller):
***Atmel-ARM
***NXP-ARM
***STMicro-ARM
***EnergyMicro-ARM
**Keine Beschränkungen
**Hier gehts zum ''[http://www.emblocks.org/web/downloads-main Download]'''
* [http://www.emide.org/ emIDE] Windows, komplette Visual Studio artige Entwicklungsumgebung (basierend auf Code::Blocks) mit GCC und Debugger (Unterstützung für Adapter von Segger) 
* [https://mbed.org mbed]: eine kostenlose Online-Entwicklungsumgebung basierend auf dem ARM Realview-Compiler, mit einer umfangreichen C++-Bibliothek für die Controllerfunktionen, integrierter Versionsverwaltung, und vielen Beispielprogrammen. Projekte lassen sich für Keil/IAR/GCC exportieren und offline weiterbearbeiten; die Bibliotheksfunktionen sind Open Source und auch kommerziell einsetzbar.
* [http://www.isystem.com/products/software/winidea-open winIDEAOpen]Die Fa. iSystem stellt mit der winIDEAOpen nun eine kostenlose Entwicklungsumgebung für alle Cortex-M Bauteile zur Verfügung. Als Compiler wird der GNU GCC verwendet und auch gleich mitinstalliert. Die IDE ist recht intuitiv und mit einer umfangreichen Hilfe ausgestattet. Das Ganze funktioniert mit dem GCC ohne Codesize Limit und auch ein Testwerkzeug (testIDEA) ist mit integriert. Hardwareseitig werden neben dem iSystem iTag50 [http://www.isystem.com/products/hardware/cortex-debugger/itag] auch die Segger J-Link Debug Probes sowie der ST-Link von ST unterstützt. Auf der Webseite von iSystem sind auch einige schöne Beispielprojekte für diverse Boards zu finden [http://www.isystem.com/download/winideaopen]. Demnächst soll noch die Unterstützung für die ARM und IAR Compiler hinzuzkommen. Hier gehts zum ''[http://www.isystem.com/download/winideaopen Download]'''
* '''Infineon''' bietet für seine '''XMC''' Prozessorfamilien auch eine kostenlose, professionell gepflegte C/C++ Entwicklungsumgebung an, ohne Einschränkungen auf bestimmte Typen oder Speichergrößen - alle erhältlichen XMC 1000er und 4000er Prozessoren werden unterstützt. Wenn man sich dazu noch eines der günstigen XMC Evaluierungsboards besorgt (XMC 1100 Bootkit, XMC 4500 Relax (lite) Kit o.ä.), hat man ein erstes Entwicklungssystem inklusive wiederverwendbaren HW-Debugger zur Verfügung. Die Entwicklungsumgebung basiert auf Eclipse, besitzt aber zahlreiche Erweiterungen samt Codegenerierung (sogenannte Apps), die gerade am Anfang viele Dinge abnehmen kann, da man die Peripherals damit einfach grafisch konfigurieren kann. Das ist bei Prozessoren, dessen User Manual einige hundert Seiten ausmacht (oder auch für Umsteiger von 8bitter oder anderen 32bittern), nicht unwichtig. Der generierte Code ist template-basiert, gut lesbar und kann später - wenn man mehr Erfahrung hat, für eigene Entwicklungen weiter nutzen und optimieren. Damit verliert man dann allerdings die Möglichkeit, Updates der generierten Codes aus den Apps zu bekommen, die Infineon ebenfalls kostenfrei zur Verfügung stellt. Die Software nennt sich ''Digital Application Virtual Engineer'' ([http://www.infineon.com/dave DAVE]) und kann nach Registrierung kostenlos für Windows heruntergeladen werden. Innerhalb von Dave kann man dann Apps und viele Beispiele (ohne weitere Anmeldung und Kosten) komplett oder selektiv (für bestimmte Prozessoren) herunterladen. Die aktuell stabile Version ist v3. Es ist eine neue DAVE Umgebung v4 in Arbeit, eine Betaversion kann heruntergeladen werden. Diese neue v4 Variante wird auch ein separates SDK besitzen, um Apps für Dave selbst schreiben zu können (z.B. Bauteilhersteller, die die Anbindung an den XMC für Kunden vereinfachen wollen). Einsteiger sollten aber mit v3 beginnen, um nicht über Bugs der Beta v4 zu stolpern (siehe auch im [http://www.infineonforums.com/forums/8-XMC-Forum XMC-Forum]).
* '''NXP''' bietet für seine '''LPC''' Prozessorfamilien eine kostenlose C/C++ Entwicklungsumgebung an. Die auf Eclipse basierende Entwicklungsumgebung ([http://www.lpcware.com/lpcxpresso LPCXpresso]) ist nach der Installation bis 8kB freigeschaltet und nach einer einfachen und kostenlosen Registrierung für 256kB. [http://www.lpcware.com/lpcxpresso LPCXpresso] steht für Windows, Linux und Mac zur Verfügung.
* '''ST''' bietet für seine '''STM32''' Prozessorfamilie eine kostenlose C/C++ Entwicklungsumgebung an. Die auf Eclipse basierende Entwicklungsumgebung kann nach Registrierung auf der Homepage heruntergeladen werden. [http://www.openstm32.org/]

Kommerzielle Entwicklungsumgebungen (zum Teil kostenlos mit Einschränkungen) für ARM-basierte Mikrocontroller sind z. B.:
* [http://timor.atollic.com/truestudio/ Atollic TrueStudio] (Windows), Eclipse-basierend inkl. Compiler und Linker für fast alle ARMs, jetzt auch kostenlos mit vielen Beispielen und ohne Codesize-Limitierung, dafür mit anderen Einschränkungen
* [http://www.cosmicsoftware.com/download_cortex_64k.php Cosmic Software] (Windows), bis 64kB kostenlos
* [http://rowley.co.uk/arm/ Crossworks ARM] (inkl. Toolchains basierend auf GCC und Clang, für Windows, Mac OS und Linux)
* [http://www.iar.com/ewarm/ IAR Embedded Workbench for ARM] (Windows)
* [http://www.keil.com/arm/ MDK-ARM von Keil/ARM] (Windows), Lite-Version bis 32kB kostenlos,
* [http://www2.keil.com/stmicroelectronics-stm32/mdk MDK-STM32 von KEIL] Speziell für STM32x0 kostenlos ohne Beschränkung
* [http://www.sisy.de/ SiSy MC++] (Windows), Demo-Version, keine Code-Begrenzung

=== Compiler für sonstige Programmiersprachen ===
* Basic: http://www.mikroe.com/mikrobasic/arm/
* Pascal: http://www.mikroe.com/mikropascal/arm/

=== Interpreter ===
* Forth: https://github.com/ekoeppen/CoreForth
* JavaScript: http://www.espruino.com/
* Lua: http://www.eluaproject.net/

=== ARM/XSCALE/CORTEX Instruction Set Simulator ===
Die Firma Lauterbach bietet unter der Artikelnummer LA-8809 einen Instruction Set Simulator für ARM Cores an. Die Demoversion ist zur Evaluierung kostenlos. Einschränkungen bestehen in der Anzahl der zu ladenden Debugsymbole. Der Simulator unterstützt alle gängigen ARM Derivate und lädt alle üblichen Debugformate, wie die des RealView, IAR und TI Compilers, oder der freien GCC Tools. Zum Simulator gibt es entsprechende zugehörige Debugtools, die allerdings käuflich zu erwerben sind.

* [http://www.lauterbach.com/frames.html?dwnload.html Download ARM/XSCALE/CORTEX Simulator]

== Debug- und Programmierschnittstellen (JTAG/SWD) ==

Alle ARM-basierten Prozessoren verwenden ein einheitliches [[JTAG]]-Interface, über das Debugging und Speicherzugriff erfolgen kann. Nicht standardisiert sind allerdings die Verfahren zum Beschreiben des Flash-ROMs, deshalb muss man beachten ob die verwendete JTAG-Software Programmierroutinen für den jeweiligen Controller besitzt.

SWD (Serial Wire Debug) ist eine neue mit den Cortex-Mikrocontrollern eingeführte Debug- und Programmierschnittstelle, die weniger Pins benötigt als JTAG. Hier wird Debug-Bandbreite bzw. Speed gegen mehr verfügbare Pins für in-circuit Debugging "getauscht". Die meisten Controller der Cortex-M0 & M3 Serie können sowohl mittels JTAG als auch mittels SWD programmiert werden, es gibt allerdings auch Exemplare (z.B. [[EFM32]] von [https://www.silabs.com Silicon Labs], XMC1100 von [http://www.infineon.com/xmc Infineon]) welche nur SWD unterstützen.

Eine Übersicht über die empfohlenen Steckerbelegungen für JTAG und SWD gibt ein [http://infocenter.arm.com/help/topic/com.arm.doc.faqs/attached/13634/cortex_debug_connectors.pdf Dokument von ARM].

Darüber hinaus gibt es noch herstellerspezifische Schnittstellen wie SPD (Single Pin Debug) von Infineon, oder vorinstallierte serielle Bootloader, z.B. beim [[STM32]] oder auch bei den [[Infineon XMC]], die dann z.B. über ein eigenes [http://www.infineon.com/cms/de/product/microcontroller/development-tools-software-and-kits/c166/xc166-development-tools-software-and-kits/software-downloads/channel.html?channel=ff80808112ab681d0112ab6b50fe07c9 Tool] ohne weitere Hardware - abgesehen von einem handelsüblichen seriellen Schnittstellenadapter - programmiert werden können.

Viele Entwicklungsboards enthalten auch einen On-Board-Debugadapter zum direkten Anschluss an USB, so dass kein externer SWD- oder JTAG-Adapter notwendig ist. Manche erlauben auch, diesen Adapter abzubrechen und für eigene Entwicklungen weiterzuverwenden, somit ist nach dem Kauf eines Eval-Kits nicht nötig, einen weiteren Adapter später nachzukaufen.

=== Günstige Beispiele zum Einstieg ===
Ein einfacher JTAG-Adapter für den Parallelport ist der "Wiggler"-kompatible, den man auch einfach selbst bauen kann. Als Software lässt sich unter Windows und Linux [http://openocd.berlios.de/ OpenOCD] (zusammen mit [[GDB]]) oder [http://rowley.co.uk Crossworks ARM] verwenden. Für USB gibt es ebenfalls OpenOCD-kompatible JTAG-Adapter.

Von NXP sind preiswerte Entwicklungskits (ca. 25€ für Evaluation-Board incl. USB-JTAG-/-SWD-Programer und Debugger) erhältlich z.B. '''[http://www.watterott.com/index.php?page=search&keywords=LPCXpresso&cat=&mnf=&x=0&y=0 Watterott]'''. Siehe dazu auch die Dokumentation von NXP zu den '''[http://www.nxp.com/documents/leaflet/75016842.pdf LPCXpresso-Entwicklungskits]''' (PDF), oder diese '''[http://www.mikrocontroller.net/wikisoftware/index.php?title=LPC1xxx_Entwicklungskit_LPCXpresso Beschreibung]'''.

Von ST gibt es günstige MBED/Arduino kompatible Nucleo Entwicklungskits (ca. 12€) z.B. '''[http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1847/PF260320?s_searchtype=partnumber]'''. Der integrierte ST-Link Debugger kann mittels SWD und OpenOCD als Software auch andere Chip programmieren. Die etwas teuereren Discoveryboards, z.B. '''[http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1848/PF260946?s_searchtype=partnumber]''', haben mehr externe Bauteile on-board, während die Nucleo Board über Shields erweiterbar sind. Nur bei Nucleo Boards ist eine UART Schnittstelle als Standard über USB zu erreichen, bei Discovery Boards mit ST-Link V2-1 müssen Lötbrücken gesetzt werden.

Auch Infineon bietet Arduino-kompatible Boards+Shields mit dem XMC1100 Prozessor und angeflanschtem Debugger an (ab ca. 16€). Weiters gibt es günstige XMC4500 Kits, die auch Ethernet, SPI-Flash und SDCard-Slot Optionen bieten. Am unteren Ende gibt es ein XMC1100 Kit samt Debugger ab ca. 5€, dieses Board für den Schlüsselbund sozusagen nennt sich treffend "XMC 2 Go". Die Preise können je nach Distributor stark variieren.
Siehe auch hier '''[http://www.infineon.com/cms/de/product/microcontroller/32-bit-industrial-microcontroller-based-on-arm-registered-cortex-registered-m/xmc-development-tools-kits-and-boards/channel.html?channel=db3a30433580b3710135a07902883872 XMC-Starter-Kits]'''.
Des weiteren werden auch schon Kits in Verbindung mit Sensoren zum Evaluieren angeboten, wie das "3D 2 Go" Board mit einem XMC1100 Prozessor und dem neuen 3D-Magnetfeldsensor von Infineon, um ein Beispiel zu nennen: '''[http://www.infineon.com/cms/en/product/sensor-ics/magnetic-sensors/3d-magnetic-sensor/channel.html?channel=5546d4624c9e0f0e014c9e105a8a001c 3D-Sensorkit]'''.

Von Silicon Labs gibt es [https://www.silabs.com/products/mcu/Pages/32-bit-microcontroller-tools.aspx Starter Kits] mit integriertem J-Link (Debugger) ab ca. 25 € z.B. das [https://www.silabs.com/products/mcu/lowpower/Pages/efm32tg-stk3300.aspx EFM32 Tiny Gecko Starter Kit] bei [http://www.mouser.de/ProductDetail/Silicon-Laboratories/EFM32TG-STK3300/?qs=%2fha2pyFadujBGJvO8YBq9JikBLXQGi%2fjwmF17imXuts5383tWpQKFA%3d%3d Mouser]

Der [http://www.segger.com/cms/jlink.html J-Link]-"Emulator" von Segger wird von vielen Softwarepaketen unterstützt und ist für den "nicht-kommerziellen" Einsatz von Studenten, Funkamateuren und Hobby-Bastler für ca. €50.- erhältlich (J-Link-Edu). Sein Umfang ist dabei auf das Flashen des Speichers und das Debuggen beschränkt. Die Trace-Option wie sie bei der PRO-Variante zur Verfügung steht, ist nicht vorhanden. Für den Preis (05/2013) bekommt man jedoch ein ausgewachsenes Werkzeug mit breiter Unterstützung und der Möglichkeit sowohl SWD als auch JTAG in einem Gerät vereint zu haben. Wenn man aber plant, ein oben genanntes Kit von ST, NXP, Infineon oder ähnlich zu kaufen kann man für ähnliche Kosten auch gleich ein CPU-Board dazubekommen - daher ist es sinnvoll, sich die Dokumentationen der Evalkits voher genau durchzusehen.

Der ULINK2 von Keil/ARM ist ebenfalls ein wirklich gutes Gerät. Leider ist er nicht ganz so günstig und seine Zusammenarbeit beschränkt sich auf die Arm/Keil IDE µVision. Er benötigt jedoch keine speziellen USB-Treiber sondern nutzt geschickt die Funktionalität der HID-Treiber des Betriebssystems. Das macht ihn sofort auf jedem Windows-Betriebssystem einsatzbereit.

Als Alternative zum Beschreiben des Flash über JTAG ist oft ein serieller [[Bootloader]] im Controller enthalten. Bei ST werden sie über einen speziellen Pin der MPU aktiviert und sind dank Kompression und das intelligente entfernen redundanter Information, bei der Übertragung genauso schnell wie JTAG/SWD Adapter.

== CMSIS - ARM Cortex Software Libraries ==

Der ARM Cortex Microcontroller Software Interface Standard (CMSIS) ist ein herstellerunabhängiger Hardware Abstraction Layer für die Cortex-M-Prozessor -Serie. Dieser ermöglicht konsistente und einfache Software-Schnittstellen für den Prozessor und die Peripherie, und vereinfacht damit die Software-Wiederverwendung.

CMSIS besteht aus folgenden Komponenten:

* CMSIS-CORE: Bietet eine Schnittstelle zum Cortex-M0, Cortex-M3, Cortex-M4, SC000 und SC300-Prozessorkern und Peripherie-Registern.
* CMSIS-DSP: DSP-Bibliothek mit über 60 Funktionen in Festkomma-(fractional q7, q15, q31) und single precision floating-point (32-bit)-Implementierung
* CMSIS-RTOS API: Standardisierte Programmierschnittstelle für Echtzeit-Betriebssysteme für Thread-Steuerung, Ressourcen-und Zeitmanagement. Implementierungen gibt es z.B. von Keil ([http://www.keil.com/pack/doc/cmsis_rtx/index.html RTX])
* CMSIS-SVD: System View Beschreibung - XML-Dateien, die die Programmiereransicht des kompletten Mikrocontroller-Systems einschließlich Peripheriegeräte enthalten

Der Standard ist für Cortex-M-Mikrocontroller skalierbar: Von der kleinsten 4 KB MCU bis zu MCUs mit anspruchsvoller Kommunikations-Peripherie wie Ethernet oder USB. Die "Core Peripheral Funktionen" benötigt beispielsweise weniger als 1 KB-Code und weniger als 10 Bytes RAM.

Beispiele:
* Software Beispiele von [http://www.energymicro.com/downloads/application-notes Energy Micro] basierend auf CMSIS

Mehr Informationen auf der [http://www.arm.com/products/processors/cortex-m/cortex-microcontroller-software-interface-standard.php ARM CMSIS Webseite].

== Siehe auch ==
* [[Linksammlung#ARM|Linksammlung (Abschnitt ARM)]]
* [[LPC1xxx]]
* [[LPC1xxx_Entwicklungskit_LPCXpresso]]
* [[Installationsanleitung_C-Entwicklungsumgebung_f%C3%BCr_LPC1xxx_von_Code_Red]]
* [[Codebase_f%C3%BCr_LPC1xxx]]
* [[ARM-elf-GCC-Tutorial]]
* [[AVR32]]
* [[Blackfin]]
* [[AT91SAM9260]]
* [[STM32]]
* [[JTAG]]
* [http://www.mikrocontroller.net/articles/EFM32 EFM32]
* [http://www.mikrocontroller.net/articles/STM32_-_Einstieg_mit_Em::Blocks STM32 - Einstieg mit Em::Blocks Tutorial]

== Weblinks ==
* [http://www.mySTM32.de Online Tutorial für den STM32]
* [http://www.myXMC.de Online Tutorial für den XMC von Infineon]
* [http://www.myUGL.de Online Tutorial für freie Grafikbibliothek, STM32, STM32F429, TFT, Touch]
* [http://embdev.net/forum/arm-gcc ARM-GCC Forum] im englischsprachigen "Ableger" von mikrocontroller.net embdev.net u.a. für WinARM, Yagarto, CS Codebench
* [http://www.arm.com/products/processors/cortex-m/index.php Cortex-M Produktseite von ARM]
* [http://infocenter.arm.com/help/index.jsp Infocenter von ARM Ltd.]
* [http://www.open-research.org.uk/ARMuC/ ARMuC ARM microcontroller Wiki]
* [http://chaosradio.ccc.de/cre151.html Chaosradio Express - Die ARM-Architektur]

== Literatur ==
*ARM Systems Developer's Guide (2004) ISBN 1558608745 [http://books.google.de/books?id=HKKUkDQE17QC&output=html Im Buch blättern] [http://booksite.elsevier.com/9781558608740/ Programmbeispiele aus dem Buch, u.a. FFT, FIR/IIR-Filter, Division, Wurzel]
*ARM Assembly Language - an Introduction (2007) ISBN 1847536964 [http://books.google.de/books?id=8KJX5R8mMvsC&output=html Im Buch blättern] [http://www.lulu.com/content/1172076 Verlagsseite "Book on demand"]
*ARM Rechnerarchitekturen für System-on-Chip-Design (2002) ISBN 3826608542
*Co-Verification of Hardware and Software for Arm Soc Design (2004) ISBN 0750677309
*ARM System-on-Chip Architecture (2000) ISBN 0201675196 [http://books.google.de/books?id=J_Fu_YTVD9gC&printsec=frontcover&output=html&source=gbs_summary_r&cad=0 Im Buch blättern]
*ARM Architecture Reference Manual ISBN 0201737191 [http://books.google.de/books?id=O5G-6WX1xWsC&printsec=frontcover&output=html&source=gbs_summary_r&cad=0 Im Buch blättern]
*Messen, Steuern und Regeln mit ARM-Mikrocontrollern ISBN 3772340172 [http://books.google.de/books?id=TKs4kN-zNYQC&output=html im Buch blättern]
*Programming Arm Microcontrollers: Using C and the Lpc2100 Family (2005? /ab 1. Dezember 2008) ISBN 0321263359
*Arm Assembly: Fundamentals and Techniques (ab 1. März 2009) ISBN 1439806101
*Reliable Embedded Systems: Using 8051 and ARM Microcontrollers (2007) ISBN 0321252918 600 Seiten mit CD [http://vig.pearsoned.co.uk/catalog/academic/product/0,1144,0321252918-TOC,00.html Inhaltsverzeichnis]
* C und C++ für Embedded Systems (u.a. ARM Cortex-M3) mitp-Verlag 2008 ISBN 382665949X
* The Definitive Guide to the Arm Cortex-M0 (Joseph Yiu) Newnes Verlag ISBN 0123854776
* The Definitive Guide to the Arm Cortex-M3 (Joseph Yiu) Newnes Verlag ISBN 185617963X

== Artikel aus der Kategorie ARM ==
<ncl style=compact maxdepth=2 headings=bullet headstart=2
showcats=1 showarts=1>ARM</ncl>
* [http://www.mikrocontroller.net/articles/EFM32 '''EFM32''']

* [http://www.mikrocontroller.net/articles/XMCxxxx '''Infineon XMCxxxx''']

* [https://www.mikrocontroller.net/articles/Cortex-A ARM Cortex A]

[[Category:ARM| ]]

KiCad

2015-10-12T08:17:37Z

Kichi: /* Problem: Der Ursprung für die Pic und Place bzw. Drill-Daten wurde verändert und lässt sich nicht zurücksetzten. */

'''KiCAD''' ist ein Open Source [[Schaltplaneditoren|Schaltplaneditor]] und PCB Layoutprogramm für Windows, Linux, Mac OSX.

Diese Seite ist zunächst eine Zusammenfassung aus den KiCAD Beiträgen im Forum. Und gleich zu Anfang ein grosses DANKE an alle KiCAD-User aus dem Forum. Ihr seid zu viele, um jeden einzeln zu nennen. Aber wer sich diese Seite durchliest und den Links folgt, wird euch kennenlernen.

Hier sollen alte und neue KiCAD-Anwender einen Anlaufpunkt finden und neue, insbesondere µC-relevante Aktivitäten stattfinden.

Diese Seite will keine Konkurrenz zum offiziellen KiCAD Wiki sein, d.h. was dort steht soll hier nicht wiederholt werden und was hier steht wird hoffentlich zum offiziellen KiCAD Wiki wandern.

Wenn ihr Kritik oder Fragen zu KiCAD habt, dann nutzt das Forum! Sobald KiCAD im Betreff steht, wird der Beitrag gelesen und nach Möglichkeit beantwortet. Auch Ideen zu dieser Seite sind sehr willkommen!

Da diese Seite hier etwas umfangreich geworden ist, empfehle ich eine Textsuche. Jeder Internetbrowser, der etwas auf sich hält, hat auch eine Suchfunktion, mit der der Text der Seite durchsucht werden kann. Bei Firefox/Iceweasel oben im Pull-down Menue unter "Bearbeiten" > "suchen" oder per Shortcut <Strg-F>

== FAQ ==

Siehe auch die offizielle FAQ: http://kicad.sourceforge.net/wiki/index.php/FAQ

TODO: Strukturierung (Allg., Schaltplan, Netlists, Module, Bibliotheken, Layout, Export, 3D)

=== Allgemein ===
* Warum gefällt dir KiCAD?
** http://www.mikrocontroller.net/topic/70905#584639
** http://www.mikrocontroller.net/topic/81396#680502
** http://www.mikrocontroller.net/topic/83311#697917
** http://www.mikrocontroller.net/topic/42614#321502
* Warum gefällt dir KiCAD nicht?
** Ich verstehe nicht, was du meinst ;-)
** http://www.mikrocontroller.net/topic/81396#680502
** http://www.mikrocontroller.net/topic/83311#697969

* Wo gibt es weitere Infos zu KiCAD?
** Offizielle Homepage: http://kicad-pcb.org/
** Die Offizielle Dokumentation: http://bazaar.launchpad.net/~kicad-developers/kicad/doc/files/head:/doc/help/en/
** Einige allgemeine Notizen zur '''Installation''' und zur '''Arbeitsweise''' von KiCad finden sich hier: https://docs.google.com/document/d/1M38ByFyqnhwGo8b_jDDyBceyZtEGeaSAuQaP9REzWrU/edit?usp=sharing
** http://www.mikrocontroller.net/topic/98034#848661 (Von 2008, also seeeehr überholt)
* Welche Leiterplattenfertiger akzeptieren KiCAD Layouts?
** http://www.pcb-pool.de KiCAD kann "Extended" Gerber RS-247-X erzeugen. Das wird von PCB-Pool akzeptiert. Dabei http://www.pcb-pool.com/download/spezifikation/deu_cmso020_ext_gerber.pdf beachten! Alternativ, wer KiCAD (noch) nicht traut, diese RS-247-X in deren (PCB-Pools) Tool GC-Prevue http://www.mikrocontroller.net/topic/120373#1092375 einlesen und als .GWK exportieren. AKTUELL August 2012: Wenn man bei PCB-Pool bestellt, ist deren GC-Prevue NICHT mehr erforderlich, weil PCB-Pool mittlerweile KiCAD *,brd Dateien direkt aktzeptiert. Siehe http://www.pcb-pool.com/ppde/info_dataformat.html
** http://fischer-leiterplatten.de Ohne Aufpreis für Gerber-Import

* Wie geht man mit KiCAD-Trollen um?
** Mit gesundem Menschenverstand. Trollregeln wie die US AIR FORCE (http://blog.wired.com/defense/2009/01/usaf-blog-respo.html) brauchen wir nicht ;-)
* Wie kriege ich raus, welche Leiterbahn welchen Netznamen hat, bzw. ich habe den Überblick verloren und weiss nicht mehr, was aus dem Layout nun was im Schaltplan ist?
**http://www.mikrocontroller.net/topic/218922#2211644. Zusatz: Funktioniert nur gut, wenn großes Fadenkreuz gewählt ist. Aktueller (zu BZR4513 vom 29. November 2013) ist http://www.mikrocontroller.net/topic/316539#3427724
** Aber ich hätte gerne noch genauere Informationen, z.b. auch über die Länge einer Leiterbahn ec.
*** Dazu in PCBnew den gleichen Button rechts wie für das Hinzufügen von Leiterbahnen aktivieren. Oder besser noch rechts den zweiten Button von oben "Netz hervorheben". Dann mit der rechten Maustaste die fragliche Leiterbahn anklicken. Unten in der Statusleiste werden die Informationen angezeigt.
* Ich würde gerne kicad OHNE Maus bedienen. Wie geht das?
**http://www.mikrocontroller.net/topic/267538#new
* Gibt es Sonderzeichen, die ich für Symbole, Module/Footprints oder Files nicht verwenden sollte2
** Ja, alles was Sonderzeichen ausser - _ . und keine Zahl ist. Siehe: http://www.mikrocontroller.net/topic/302664#3249204

=== Installation ===
* Woher beziehe ich KiCad?
** KiCad hat wegen der schnellen Entwicklung z.Z. ein "rolling release", d.h. es gibt eigentlich keine "offiziellen" Releases, sondern jeder Anwender ist dazu angehalten, sich selber sin KiCad aus den aktuellen Sourcen selber zu compilieren. Dazu gibt es aber Skripte zur Unterstützung, die dieses automatisieren, so dass man nicht unbedingt C/C++ Kenntnisse braucht. Es ist wirklich recht einfach. Ein offizielles "stable release" ist aber wieder für den Spätsommer/Herbst 2015 geplant. Die meisten gängigen Linux Distributionen enthalten aber "old stable" KiCad Releases in ihren Repositories.

** Offizielle Seite (alle Betriebssysteme): http://kicad-pcb.org/download/
** Leider recht alt: http://iut-tice.ujf-grenoble.fr/cao/
** Windows: http://www2.futureware.at/~nickoe/
*** Welcher Typ? ...-x86_64.exe oder ...-i686.exe ? Ich brauche x86 32 bit.
**** Für Windows PC 32 bit die ...-i686.exe, und für Windows PC 64 bit ...-x86_64.exe.
** Veraltet: http://www71.zippyshare.com/v/28617008/file.html Die Quelle ist hier genannt. https://groups.yahoo.com/neo/groups/kicad-users/conversations/messages/18534
* Kicad entwickelt sich rasant. Wo finde ich eine Liste der Versionsänderungen?
** Auf der Kicad Launchpad Seite via bazaar. Siehe: http://www.mikrocontroller.net/topic/298311#3187885
* Ich habe KiCad unter Linux installiert, aber wenn ich KiCad starten will, passiert einfach nichts, oder ich erhalte eine Fehlermeldung wie: "Datei nicht gefunden". Siehe: http://www.mikrocontroller.net/topic/307517#new
** 1) KiCad und seine zugeordneten Programme sollten im Suchpfad stehen. Es wird für Debian und Ableger empfolen, KiCad unter usr/local/bin zu installieren. Anmerkung: Das ist die aktuelle Verfahrensweise. Oktober 2013 wurde aber noch folgende Struktur verwendet:
*** /usr/bin - Binaries (executable files).
*** /usr/share/doc/kicad/ - Various documentation.
*** /usr/share/doc/kicad/help - Interactive help.
*** /usr/share/kicad/demos - Sample schematics and printed boards.
*** /usr/share/kicad/internat - Dictionaries for interface localization.
*** /usr/share/kicad/library - Interface localization files.
*** /usr/share/kicad/modules - Module libraries for printed boards.
*** /usr/share/kicad/modules/packages3d - 3D component models (.wrl and .wings format).
*** Quelle: http://iut-tice.ujf-grenoble.fr/cao/install.txt Hier sind auch Hinweise für Windows user enthalten.

** 2) User sollten dort Lese- und Ausführungsrechte haben. Aber keine Schreibrechte.
** 3) Wenn ein fertiges Packgage auf einem 64 bit System verwendet wurde, könnte es daran liegen, das es für 32 bit compiliert wurde, und nicht für 64 bit. Es gibt zwei Möglichkeiten:
*** a) Selbst aus den Sourcen für sein eigenes System compilieren.
*** b) Die Runtime Libs für 32 Bit könnten fehlen. Nachinstallieren mit sudo apt-get install ia32-libs. Siehe: http://www.mikrocontroller.net/topic/307517#3307638
* Ich habe das umgekehrte Problem: 32bit system aber 64bit Binarys.
** Selbst aus den Sourcen neu compilieren.
*Ich will/muss mir KiCad selber compilieren. Wie gehe ich vor?
** Aktuell nach: http://www.kicad-pcb.org/display/DEV/Build+KiCad
**
**Veraltet! siehe: http://www.mikrocontroller.net/topic/310766#3351269 Aber Achtung. Diese Anleitung (Oktober 2013) muss nicht aktuell sein.

* Sicherheitseinstellungen von Java sind für PCBnew unter JAVA -> JAVA konfigurieren zu finden.

* Diskussionen zum Thema Installation und compilieren:
** FEDORA: http://www.mikrocontroller.net/topic/338600#new
** ARCH Linux: http://www.mikrocontroller.net/topic/339509#new
* Konfigurationsdateien:
** Ab BZR5114 (ca. 5. September 2014) hat sich der Ordner für die Files mit den Konfigurationsdaten geändert. Unter Linux sind nun die Konfigurations Dateien in $HOME/.config/kicad (entsprechen der FreeDesktop.org Spezifikation). Um Ihre gegenwärtigen Konfigurierungen zu erhalten, können die KiCAd Konfigurationsfiles aus dem Home-Verzeichnis in den aktuellen Ordner kopiert werden. Es muss allerdings der führende "." (Punkt) der Datei entfernt werden. Ebenso muss die globale "fp-lib-table" aus dem home-Verzeichnis dorthin kopiert werden. Windows User müssen KiCAD leider reconfigurieren. Es gab keinen einfachen Weg um die Registry-Keys in die Konfigurationsdateien zu extrahieren. Die Konfigurationsdateien unter Windows werden genau wie die fp-lib-table im %APPDATA%\kicad Ordner gespeichert. Es ist angeraten, sämmtliche Reste der KiCAD Installation aus der Registry zu entfernen, wenn nicht KiCAD Versionen vor der BZR5114 verwendet werden. Diese Lösung beseitigt die $home Ordner "verschmutzung" und vermeidet die Benutzung der Windows registry, wie es häufig gewünscht wurde. Für OS X User ergeben sich keine Änderungen. Link auf die Originalnachricht (englisch): https://groups.yahoo.com/neo/groups/kicad-users/conversations/messages/18889 (KiCAD-User Group, 05. September 2014, Titel: Configuration file location changes (#18889) Autor: Wayne Stambaugh)

=== Schaltplan ===
* Wie stellt man die Blattgrösse beim Schaltplan ein?
** In Page Settings die Blattgröße verstellen (zB von A4 auf A3) http://www.mikrocontroller.net/topic/33653#974295
* Wie kann man den Schaltplan auf mehreren Seiten verteilen (hierachical sheets)?
** http://www.mikrocontroller.net/topic/96060
** http://www.mikrocontroller.net/topic/117873#1060062
*Wie geht man mit "Power Pins" in hierachischen Schaltplänen um?
**http://www.mikrocontroller.net/topic/207905#new
* Wie kann man die "hierachical sheets" benutzen, um aus vorgefertigten Subschaltplänen mit immer gleichen Bauteilgruppen rationell Schaltpläne zusammenzustellen (Building Blocks)?
** http://www.mikrocontroller.net/articles/KiCAD#Tipps.26Tricks:_Building_Blocks
** http://www.mikrocontroller.net/topic/175597#1687653
** http://www.mikrocontroller.net/topic/178683#1724114
* Ich habe einen hierarchischen Schaltplan angelegt. Wenn ich ihn ausdrucke, werden die Subschaltpläne in der Reihenfolge ausgedruckt, in der sie oben in der Übersicht stehen. Diese Reihenfolge ist aber in meinem Fall ungünstig. Wie kann ich diese nun ändern?
** Leider im Programm z.Z. noch nicht. Trozdem ist es machbar. Entweder von Hand oder mit einem Python Skript. Näheres zu beidem findet sich hier: http://www.mikrocontroller.net/topic/288394#3064087 . Ein Python 3 Skript, das den Umgang mit dem Kicad-Schaltplan erleichtert, findet sich hier: [[Media:PyKicadSchematic-ID_Interchanger_RevC.zip]].
*Wie geht man mit Bussen um?
**http://www.mikrocontroller.net/topic/208870#new
** und speziell bei hierachischen Schaltplänen: http://www.mikrocontroller.net/topic/209156#new
* Wie kann man Schaltplanentwurf (KiCAD) und Schaltungssimulation (Spice) verbinden?
* Ein Tutorial zum Symboleditor für KiCAD, mit dem die Symbole für das Schaltplanmodul (EEschema) erzeugt bzw. editiert werden, findet sich hier: [[Media:SymboleFuerKiCad318082009-RevC-DE.pdf]]. Zur Erstellung von Schaltplansymbolen in aufgelöster Darstellung (Relais: Kontaktsätze einzeln und getrennt von der Spule; IC: Versorgungsspannung getrennt von den einzelnen Gattern) siehe http://www.mikrocontroller.net/topic/273891#new. Bei Problemen noch mal hier nachlesen: http://www.mikrocontroller.net/topic/294095#3136180
* Wie kann man im Schaltplan Symbole zum Verschieben gruppieren?
** Siehe http://www.mikrocontroller.net/topic/170913#
* Und wenn es darum geht, eine solche Gruppe in einen anderen Schaltplan oder Subschaltplan zu verschieben?
** Die Gruppe ins "Clipboard" stecken. Dazu nach dem Markieren der Gruppe rechte Maustaste beklicken, und dort "Gruppe speichern" wählen. Nun ist die Gruppe im Clipboard. jetzt in den gewünschten Unterschaltplan gehen und die Gruppe dort mithilfe des Clipboardbuttons (Das Klemmbrett Symbol links neben dem "Undo"-Button) in den Schaltplan einfügen. NICHTS mit der rechten Maustaste versuchen! Siehe auch: http://www.mikrocontroller.net/topic/244836#2499782 Das ganze geht nicht nur mit Subschaltplänen, sondern auch genauso in einen ganz anderen Schaltplan, den man dann halt in Eeschema öffnen muss, hinein. Wenn nach dem Einfügen allerdings nur ein Kästchen mit Fragezeichen erscheint, waren die nötigen Symbolbibliotheken für diese Symbole noch nicht in der Projektdatei eingetragen. Das mus man nun nachholen, indem man unter "Einstellungen" die "Bibliotheken" wählt, und die passenden Bibliotheken einträgt. Wenn man nicht genau weiss, wo diese zu finden sind, kann es sinnvoll sein, die *-cache.lib des Herkunftsschaltplanes einzubinden.
* Wie wird man den merkwürdigen Rahmen los?
** 1) Bei neueren KiCad Versionen, ab ca. Mitte 2013 (von mir getestet ab BZR 4513 29 November 2013) kann man sich eine Vorlage ohne Rahmen erstellen. Dazu den pl_editor (der ganz rechte Button im KiCad Hauptfenster) starten, und FAST alles entfernen. Dazu in der linken Spalte nacheinander alles aktivieren, und mit rechts anlicken und dann "entfernen" wählen. Aber vorsicht, wenn alles Entfernt wird, taucht das Original Layout wieder auf. Workaround war bei mir, eine zusätzliche Alibilinie hinzuzufügen, die von X 0,000 Y 0,000 bis X 0,001 Y 0,000 reicht. Das ist ein "Fliegenschiss" in der linken oberen Ecke. Jetzt kann alles andere gelöscht werden. Den so geleerten Rahmen unter einem beliebigen Namen mit der Endung .kicad_wks wegspeichern. Im geöffneten Schaltplan kann der dann unter Datei > Seite einrichten ganz unten unter "page layout file description" die entsprechende Datei eingebunden werden. Es bleibt aber dem Anwender offen, ob er den Rahmen komplett entfernt, oder noch Felder mit Textbeschreibungen übernimmt. Für gesteigerten Komfort kann diese Datei dann auch in ein Template eingebunden werden.
** 2) Beim Ausdrucken Frame deaktivieren.
** 3) Als SVG exportieren. Dort den Frame deaktivieren.
** Siehe: http://www.mikrocontroller.net/topic/343509#3791448
* Wie schalte die Footprint-Namen in Eeschema global ab?
** http://www.mikrocontroller.net/topic/253564#new
* Ich habe ein Problem mit dem ERC. Ständig kommt die Fehlermeldung: "Pin ist mit anderen Pins verbunden, wird jedoch von keinem angesteuert"
** Netze, die nicht angesteuert werden, werden von Kicad misstrauische beäugt. Das "nicht ansteuern" kann aber schnell passieren, weil Kicad u.A. erwartet, das irgendwo ein Spannungsversorgung ist. Wenn diese aber z.B. über eine Sicherung oder einen Pull-up Widerstand gehen, so wird das nicht bemerkt, weil Sicherungen und Widerstände (oder auch Entstördrosseln) "passive" Pins haben. Siehe: http://www.mikrocontroller.net/topic/292988#new und http://www.mikrocontroller.net/topic/298401#new
* Ich habe ein Problerm mit dem ERC. Immer in Verbindung mit GND kommt die Fehlermeldung: "Pin ist mit anderen Pins verbunden, wird jedoch von keinem angesteuert"
**Siehe: http://www.mikrocontroller.net/topic/284089#new
* Beim ERC kommt die Fehlermeldung "PIN not connected" an Verbindungen, die per Label angeschlossen sind. Was ist da falsch?
**Sie sind tatsächlich nicht angeschlossen. Siehe: http://www.mikrocontroller.net/topic/346976#new
* Wie ist der Zusammenhang zwischen Bauteilen und Netznamen? Wie bekomme ich heraus, an welchem Netz mein Bauteil angeschlossen ist?
** Eeschema vergibt bzw. aktualisiert erst dann Netznamen, wenn eine Netzliste erzeugt wird. Darauf besteht entweder ein Zugriff über PCBnew, oder aber mit einem Editor. Siehe Beitrag http://www.mikrocontroller.net/topic/316539#new
* Ich habe einen Schaltplan geöffnet, aber alle oder einige der Symbole zeigen nur Kästen mit Fragezeichen.
** Es fehlen die passenden Symbolbibliotheken für diese Symbole.
*** Diese müssen in der Liste der Bibliotheken nachgetragen werden.
*** Hat man von anderswo einen Schaltplan bekommen, kann dieser auf anderen Symbolbibliotheken beruhen, als man selber verwendet. Aus diesem Grunde existiert zu jeder Schaltplandatei (Dateiname.sch) eine Cache Bibliothek (Dateiname-cache.lib). Diese enthält alle im Schaltplan verwendeten Symbole, und sollte darum mit dem Schaltplan zusammen übergeben werden.
*** Ab BZR4646 (Jan./Feb. 2014) behandelt KiCad Symbolnamen "Case Sensitive". Das führt zu Problemen mit älteren Schaltplänen, wo "Mixed Case" Symbolnamen aus den Bibliotheken automatisch in "Upper Case" Symbolnamen konvertiert wurden. Diese werden jetzt nicht mehr erkannt. Näheres siehe: http://www.mikrocontroller.net/articles/KiCAD#Problem:_Case_Senitive_Symbols_ab_BZR4646_.28Jan..2FFeb._2014.29
*Wieviele Textfelder für Symbole kann ich anlegen und wie groß dürfen diese sein?
** Mindestens 35 Felder, die mindestens 256 Zeichen (tatsächlich deutlich mehr) beinhalten können. Aber Zeilenumbrüche gehen nicht. Siehe: http://www.mikrocontroller.net/topic/331201#3658695
* Ich habe ein Symbol im Symboleditor geändert. Aber irgendwie taucht diese Änderung dann in Eeschema trotzdem nicht auf.
** Die Reihenfolge der Einträge in der Bibliotheksliste ist wichtig. Bei gleichem Namen wird immer das zuerst gefundene Symbol verwendet. Steht die -cache.lib in der Reihenfolge zu oberst, wird immer zuerst das Bauteil aus der -cache.lib verwendet. Beheben: Die -cache.lib aus der Bibliotheksliste von Eeschema austragen und neu eintragen, so dass sie unten angefügt wird, und zuletzt geladen wird. Alternativ: Bei Änderungen einen neuen Namen für das Symbol vergeben. Z.B. durch das Pflegen eines Revisions- oder Datecode im Symbolnamen. Einfach nur die -cache.lib löschen langt möglicherweise nicht, weil diese u.U. mit alten Daten neu geschrieben wird (wenn z.b. Eeschema dabei nicht geschlossen ist). Siehe: http://www.mikrocontroller.net/topic/331201

=== Netlist ===
* Was genau muss man beim Übergang vom Schaltplan (SCH) zum Layout (BRD) machen?
** http://www.mikrocontroller.net/topic/33653#898771
** http://www.mikrocontroller.net/topic/39243#290309
** http://www.mikrocontroller.net/topic/39243#891530
* Kann man fertige Netzlisten für Gruppen von Bauteilen einbinden?
** http://www.mikrocontroller.net/topic/33653#1462871
* Kann man Daten für automatische Bestückung erzeugen?
** Ja. aber nicht in CVpcb für die Symbol > Footprint Zuordnung, sondern im Layout Modul PCBnew.
* In meiner Netlist fehlen Bauteile, die im Schaltplan vorhanden und angeschlossen sind. Der ERC läuft problemlos durch. Die Annotation auch, aber nach Erstellung der Netlist sind die Symbole plötzlich mit einem vorangestellten "#" im Schaltplan bezeichnet.
** Vermutlich sind sie versehentlich als "virtuelles" Bauteil gekennzeichnet. Siehe http://www.mikrocontroller.net/topic/268626#new
* Wie exportiere ich eine Netlist NUR für einen Subschaltplan?
** Das geht, nachdem dieser Schaltplan explizit in EEschema geöffnet wurde. Siehe: http://www.mikrocontroller.net/topic/330740#new
* Ich finde CVpcb nicht mehr am gewohnten Platz zwischen all den anderen Startbuttons!
** CVpcb ist inzwischen aus diesen entfernt worden, und durch Startbuttons für den Symboleditor und den Footprinteditor ersetzt worden. Dafür kann CVpcb jetzt direkt aus Eeschema heraus gestartet werden. Es findet sich jetzt im oberen Pulldown Menue unter "Werkzeuge" und dann "Bauteilfootprints zuweisen" oder in der oberen Buttonleiste als dritter Button von rechts (BZR5175 vom 11 Oktober 2014).
** Sollte KiCad abstürzen, wenn man versucht, CVpcb zu starten, so kann man CVpcb auch direkt aus einem Terminal oder aus der Eingabeaufforderung heraus starten.
** Versuchsweise mal 10 Minuten warten.....bei Problemen mit der Erkennung von Symbolnamen und Footprintnamen (beim öffnen ganz alter Projekte mit alten Dateiformaten) kann es manchmal extrem lange dauern.
* Was bedeuten die Maßangaben in der Netlist?
* Wie überträgt man Kicad Schaltpläne in QUCS Schaltpläne für Simulation?

=== Layout ===
* Wie stellt man die Rastergrösse im Layout ein?
** Mit der Rechten Maustaste in das Board klicken. Es poppt ein Menue auf. Dort Raster wählen..... Geht im Modul-Editor genauso.
* Wie verteile ich die übereinander geladenen Bauteile?
**Oben das IC Symbol mit den zwei Pfeilen (Mode footprint) aktivieren und mit der rechten Maustaste auf der Platine im Menü "Global spread and place" anwählen und die gewünschte Art auswählen.
* Wie werden Pads und Leiterbahnen verbunden?
**Siehe: http://www.mikrocontroller.net/topic/119755#1081455
**Aktueller: http://www.mikrocontroller.net/topic/220733#new
* Ich kann keine Leiterbahnen ziehen!
** Vermutlich hast Du den automatischen DRC (Design rule check) aktiviert. Deaktiviere ihn halt. In PCBnew im linken Buttonbar der oberste Button (Insekt mit Verbotszeichen). http://www.mikrocontroller.net/topic/306476#new
* Mir fehlen Airwires/Luftlinien/Gummibänder!
** Vieleicht die falschen Pins als Typ "Spannungsausgang" definiert? Siehe: http://www.mikrocontroller.net/topic/330817#3620918
* Ich bekomme immer eine Fehlermeldung vom DRC, das ein Pad nicht angeschlossen ist, aber ich habe es angeschlossen.
**Siehe: http://www.mikrocontroller.net/topic/204717#2018724
* Ich will ein Bauteil für geringeren Leiterwiderstand sowohl auf der Unterseite- als auch der Oberseite anschliessen. KiCAD löscht aber immer den alten Leiterbahnzug, wenn ich den neuen lege.
** Deaktiviere unter Einstellungen->Allgemein das "auto-entfernen-von-Leiterbahnen" (einfachste Lösung).
** Alternativ: Designe dafür Bauteile mit speziellen Pads. http://www.mikrocontroller.net/topic/187606#1823596 (realistischste u. sauberste Lösung, aber etwas umständlich.)
* Wie kann man ein Bauteil mit Pads und Leiterbahnen bewegen?
** http://www.mikrocontroller.net/topic/118539#1067219
* Wie füllt man eine Fläche aus?
** Siehe: http://www.mikrocontroller.net/topic/93131#854802
** Etwas aktueller: http://www.mikrocontroller.net/topic/182271#1772119 Zweiter Teil des Posts.
** Und wie erzeuge ich konzentrisch ineinanderliegende Flächen?
*** Siehe: http://www.mikrocontroller.net/topic/327475#new
** Ja, aber meine Fläche wird nicht gefüllt oder es passiert was ganz merkwürdiges.
***Siehe: http://www.mikrocontroller.net/topic/298692#new
***Konkreter: Es sollte darauf geachtet werden, das mindestens ein Endpunkt oder ein Via oder ein Knickpunkt der Leiterbahn, die mit der zu füllenden Fläche verbunden sein soll, innerhalb der als zu füllen definierten Fläche liegen. Siehe http://www.mikrocontroller.net/topic/366199#new
* Ich habe eine Platine, die von oben und unten bestückt ist. Wenn ich jetzt Bauteile zusammengruppiere, um sie gemeinsam zu verschieben, erwische ich immer alle Bauteile auf Vorder- und Rückseite. Wie bekomme ich das jetzt hin, das ich nur Module auf einer Seite bewege?
** Indem im Lagenmanager die Seite, die nicht bewegt werden soll, abgeschaltet wird. Siehe: http://www.mikrocontroller.net/topic/311586#new
* Wie bekommt man ein vernünftiges Boardoutline hin?
** http://www.mikrocontroller.net/topic/96060#1057511
* Wie erstellt man eine Befestigungsbohrung / nichtdurchkontaktierte Bohrung?
** VERALTET: http://www.mikrocontroller.net/topic/179308#1726990
** VERALTET:http://www.mikrocontroller.net/topic/120373#1122219 ?????
** KiCAD kann mittlerweile auch direkt nichtdurchkontaktierte Bohrungen erzeugen. Siehe dazu http://www.mikrocontroller.net/topic/263069#2732405 Enthält auch allgemeine Informationen zum Umgang mit durchkontaktierten und nicht durchkontaktierten Bohrungen.
* Ich möchte für Passermarken / Fiducials eine deutlich größere Freistellung in der Lötstoppmaske haben. Wie geht das?
** http://www.mikrocontroller.net/topic/266730#2779498
* Wie geht das überhaupt mit den Lötstoppmasken?
** http://www.mikrocontroller.net/topic/283721#new
* Ja, aber die Lötstoppmaske wird leider nicht angezeigt.
** http://www.mikrocontroller.net/topic/298028#new
* Ich möchte Text und Markierungen/Grafik statt im Bestückungsdruck im Lötstopplack erstellen. Geht das überhaupt und wie ist das zu bewerkstelligen?
** Das geht, und dazu ist der Text oder die grafischen Linien/Kreise direkt in die Lötstoppmaske zu schreiben. Siehe: http://www.mikrocontroller.net/topic/347702#new Die Lötstoppmasken Lagen heissen F.Mask (Bestückungsseite) und B.Mask (Lötseite).
* Wie kann man Bauteilmaße in den Ansichten (Footprint, Layout, 3D-View) anzeigen?
** Anzeige im Layout: Layer "Zeichnung" anwählen. In der rechten Menueleiste "Bemaßung hinzufügen" wählen. Das ist der fünfte Button von unten mit der "blauen Bemaßung". Jetzt an einer Stelle links ins Layout klicken. Maus verschieben und noch einmal links klicken und die Maus seitlich verschieben. Es wird ein Maßpfeilsystem zwischen erstem und und zweitem Mausklick angelegt, deshen höhe man mit der Maus einstellen kan. Ein weiterer linker Mausklick fixiert das System. Das Anklicken der Beschriftung mit der rechten Maustaste erlaubt das Editieren. Das System wird immer in der Einheit angelegt, die in der linken Menueleiste vorgewählt wurde. Die Rasterung der aktuellen Einstellung wird auch übernommen. Späteres Ändern von Einheit- und Raster ändern die Beschriftung nicht mehr. In 3D und im Footprint geht diese Möglichkeit nicht.
** Weitere Möglichkeiten: Einen Maßstab als footprint/Modul anfertigen und zum Messen in das Board einfügen.
** Wenn man im Layout aber direkt etwas ausmessen möchte, so geht das über den relativen Nullpunkt. Unten im Rahmen rechts sind vier Felder. Die beiden linken zeigen die absoluten Koordinaten, an, die beiden rechten die relativen Koordinaten in Bezug auf einen relativen Nullpunkt. Defaultmäßig stimmen absoluter und relativer Nullpunkt ersteinmal überein. Per "Space bar" drücken setzt Du den relativen Nullpunkt an den Ort des Mauszeigers. Wenn Du nun die Maus verfährst, zeigen die relativen Koordinaten nun den vertikalen und horizontalen Abstand zum Nullpunkt. Die Diagonale muss leider über den Pythagoras selber ausgerechnet werden, oder indem man die Polarkoordinateneinstellung wählt (linke Menueleiste). Durch geschicktes setzten des Nullpunktes kann man nun auf der Platine herummessen. Winkel können auch über die Polarkoordinateneinstellung gemessen werden. Im Moduleditor geht das analog. Das 3D-View kann zur Zeit (Jannuar 2011) überhaupt keine Bemaßung.
* Wie kann man mit der KiCAD Version 20100314 '''einseitige''' Platinen erstellen?
** http://www.mikrocontroller.net/topic/172015#1651239
** aktueller: http://www.mikrocontroller.net/topic/172015#1794699
*Und wie teile ich KiCAD mit, daß der Autorouter nur eine Seite verwenden soll?
** Auf die doofe Tour: Erst in KiCAD zweiseitig wählen, und dann beide Lagen im Autorouter als "Unterseite" wählen.
* Wie kann man den Nullpunkt eines Layouts verschieben?
** http://www.mikrocontroller.net/topic/179680#1730452 für den Layout Editor PCBnew. Im Moduleditor bei Erstellung eines Footprints kann man den Ankerpunkt frei Mithilfe des Anker-Tools aus der rechten Menüleiste (das Ankersymbol) setzten. Gleiches gilt für den Symboleditor.
* Wie gehen runde Bögen in KiCAD?
**http://www.mikrocontroller.net/topic/202512#1994063
* Wie benutze ich den interaktiven Router (Push & Shove) in PCBnew?
** Dazu muss in PCBnew im Pulldown-Menue unter "Ansicht" die Option "Canvas nach OpenGL umschalten" oder "Canvas nach Cairo umschalten"gewählt werden. Wenn man nun, wie gewohnt, aus der rechten Button Leiste das Verlegen von Leiterbahnen wählt, eine Leiterbahn/Luftlinie wählt und rechts anklickt, erhält man den interaktiven Router. Aber Achtung - wegen des geänderten Kontextmenues kann es sinnvoll sein, für andere Tätigkeiten auf die Voreinstellungen zurückzuschalten.
* Ich habe mein Board fertig geroutet, stelle aber jetzt fest, das ich noch einige Leiterbahnbreiten ändern muss. Wie geht das am einfachsten?
**http://www.mikrocontroller.net/topic/205851#new
*Ich kann Pads nicht anschlissen bzw. ich bekomme vom DRC Fehlermeldungen, daß ich Pads nicht angeschlossen habe, obwohl sie angeschlossen sind.
**http://www.mikrocontroller.net/topic/204717#new
*Wie kann ich Daten für automatische Bestückung (Pick&Place) erzeugen?
** In PCBnew unter Datei > Fertigungsdateien > Bauteile Positionsdatei (.pos). Aber dieses verlangt, das die Footprints auch die richtigen Informationen dazu enthalten. Um diese einzustellen, den Footprint im Moduleditor öffnen und unter dem Button "Bauteileigenschaften" in "Attribute" eine Markierung bei "Normal+Einfügen" machen. Dann wird der Ankerpunkt des Modules für die Positionsdatei verwendet. Damit sinnvolle Daten entstehen, sollte der Ankerpunkt in die Mitte des Footprintes gesetzt worden sein.
*Und wie erzeuge ich ein Excellon Drillfile?
** In PCBnew unter Datei > Fertigungsdateien > Bohrdaten. Die Datei enthält auch eine Werkzeugliste. Kicad legt u.U. zwei Drillfiles an, wenn erforderlich. Eines für durchkontaktierte, und eines für nicht durchkontaktierte Bohrungen. Wer eine extra Liste und eine Statistik wünscht, muss auch noch "Bericht über Bohrung" anwählen.
** Bei mir wird aber nur ein Drillfile erzeugt. Was läuft falsch?
***Die NPTH Drills müssen im Pad-Editor explizit als solche gekennzeichnet werden. In PCBnew erkennt man sie dann als dicke gelbe Flächen. Siehe: http://www.mikrocontroller.net/topic/322941#3989397 Bei älteren Footprints ist das aber noch nicht komplett umgesetzt.
* Wenn PCBnew die Netzliste eingelesen hat, liegen alle Bauteile auf einem Haufen. Zum Plazieren eines herausgreifen ist mühsam. Wie geht das am einfachsten?
** In PCBnew "T" drücken. Es poppt ein Fenster auf, wo man die Bauteilreferenz (den Namen) eingeben kann. Und schon hängt das Bauteil zum Bewegen am Zeiger. Die Bedienung ist letztlich genauso wie das "m" und die Komandozeile in Eagle. Siehe http://www.mikrocontroller.net/topic/293903#3133990
** "Raef" hat ein Python Script erstellt, das Bauteile automatisch ähnlich der Anordnung im Schaltplan plaziert. Siehe: http://www.mikrocontroller.net/topic/293903#3245990
* Ich habe ein fertiges Layout. Jetzt möchte ich aber andere Footprints verwenden, und anschliessend nicht neu routen müssen. Wie geht das?
** Üner CVpcb und Neueinlesen der Netzliste. Siehe: http://www.mikrocontroller.net/topic/297885#new
* Ich will links herum routen, aber Kicad meint unbedingt rechts herum (...oder umgekehrt). Wie kann ich die Leiterbahnen "flippen"?
** Mit "/" (Slasch) http://www.mikrocontroller.net/topic/280028#new
* Ich hätte gerne die Tastenkürzel in kicad so wie in meinem gewohnten Programm. Wie geht das?
** Siehe http://www.mikrocontroller.net/topic/283959#3007173 . Vieleicht ist einer ja so nett, und stellt Konfigurationsfiles für Leute die aus EAGLE, ORCAD oder so wechseln, bereit.
* Ich habe ein kleines Board fertig geroutet. Jetzt möchte ich mehrere davon zu einer größeren Platine zusammenführen (sog. Mehrfachnutzen), um sie rationeller fertigen zu können.
** Siehe http:http://www.mikrocontroller.net/topic/292334#new . Das geht natürlich genauso, wenn man verschiedene Platinen so zu Nutzen zusammenfügen möchte, oder halt kleinere Teillayouts zu einem Gesamtboard.
* Ich habe einen Schaltplan mit Subschaltplänen, zu denen ich separate Layouts erstellen möchte.
** Dazu diesen Subschaltplan explizit in EEschema öffnen, und die Netzliste nur für diesen Subschaltplan exportieren. Weitergehen wie üblich. Siehe: http://www.mikrocontroller.net/topic/330740#new
* Ich möchte Varianten eines Layouts erstellen. Was ist dazu zu sagen? Siehe: http://www.mikrocontroller.net/topic/330740#3616697
** Siehe http://www.mikrocontroller.net/topic/292123#new
* Wie importiere ich DXF-Dateien in PCBnew?
** Dafür existiert eine Import Funktion in PCBnew: Datei > Importieren > DXF-Datei. Siehe http://www.mikrocontroller.net/topic/327628#new
* Wie wird man den merkwürdigen Rahmen los?
** 1) Genauso wie im Schaltplan. Dazu den pl_editor (der ganz rechte Button im KiCad Hauptfenster) starten, und FAST alles entfernen. Dazu in der linken Spalte nacheinander alles aktivieren, und mit rechts anlicken und dann "entfernen" wählen. Aber vorsicht, wenn alles Entfernt wird, taucht das Original Layout wieder auf. Workaround war bei mir, eine zusätzliche Alibilinie hinzuzufügen, die von X 0,000 Y 0,000 bis X 0,001 Y 0,000 reicht. Das ist ein "Fliegenschiss" in der linken oberen Ecke. Jetzt kann alles andere gelöscht werden. Den so geleerten Rahmen unter einem beliebigen Namen mit der Endung .kicad_wks wegspeichern. Im geöffneten Schaltplan kann der dann unter Datei > Seite einrichten ganz unten unter "page layout file description" die entsprechende Datei eingebunden werden. Es bleibt aber dem Anwender offen, ob er den Rahmen komplett entfernt, oder noch Felder mit Textbeschreibungen übernimmt. Für gesteigerten Komfort kann diese Datei dann auch in ein Template eingebunden werden.
** 2) Beim Ausdrucken Frame deaktivieren.
** 3) Als SVG exportieren. Dort den Frame deaktivieren.
** 4) Beim Plotten (z.B. in Gerber) Frame deaktivieren. Ist eigentlich defaultmäßig eingestellt.
** Siehe: http://www.mikrocontroller.net/topic/343509#3791448
* Ich möchte einen bestimmten Footprint verwenden (von dem ich weiss, dass er existiert), kann ihn aber in der Auswahl der Footprints von PCBnew nicht finden.
**Die Bibliothek, in der er enthalten ist, muss erst in das Verzeichnis der aktiven Bibliotheken in PCBnew eingetragen werden.
* Ich möchte Footprint-Bibliotheken in das Verzeichnis der verwendeten Bibliotheken von PCBnew eintragen. Wie geht das?
** https://www.mikrocontroller.net/topic/372123#new
* Ich habe Probleme mit den Umgebungsvariablen KISYSMOD, KISYS3DMOD, KIPRJMOD, KIGITHUB beim Eintragen der Bibliothekstabellen.
** KISYSMOD ist eine Variable, die den Pfad zu den global verwendeten KICAD-Modulen (Footprints) angibt. KIPRJMOD ist das gleiche, für projektspezifische Module. KISYS3DMOD beschreibt den Pfad zu den 3D-Modellen, und KIGITHUB weisst den Pfad ins Internet zu den Githubbibliotheken.
** Nähere Informationen dazu findet man hier: http://www.mikrocontroller.net/topic/344139#new und hier : http://www.mikrocontroller.net/topic/344029#new
** Falls alles nichts hilft: Nan kann den Pfad auch komplett am Stück in die Bibliothekstabelle eintragen. Copy&Paste funktioniert dort aber nicht per rechtem Mausklick, sondern per <Str-c> (Kopieren) und <Str-v> (einfügen). Einfacher als die Bibliothekstabelle lässt sich darum die fp-lib-table Datei per Editor bearbeiten. Unter Linux findet sich die Tabelle für globale Bibliotheken bis zur BZR5113 direkt im Homeverzeichnis. Ab BZR5114 (ca. 5. September 2014) fiondet sich die globale fp-lib-table in $HOME/.config/kicad. Die fp-lib-table für projektbezogene Bibliotheken finden sich in den korrespondierenden Projektverzeichnissen.
* Ich würde gerne aus den Mikrowellen Tools die Funktion "Polynominales Muster" verwenden. Dabei werde ich nach einem KiCad-Shapefile gefragt, aber ich weiss nicht, wie das File aussehen muss.
** Einen Hinweis zum Aussehen des Files gibt es hier: https://www.mikrocontroller.net/topic/369330#4166392 Allerdings müssen die Werte der Polynomstruktur anderweitig berechnet werden, und mit einem Editor manuell in diese Form gebracht werden.
* Wie erstelle ich koplanare Leitungen in KiCad?
** siehe diese Diskussion: https://www.mikrocontroller.net/topic/370700#new
* Ich möchte Bauteile im Kreis oder in einem Gittermuster/Array anordnen. Gibt es dafür automatische Hilfestellungen?
** Ja. Objekt Deiner Wahl rechts anklicken, eventuell Auswahl verfeinern, und dann im aufpoppenden Menue "Array erstellen" wählen. Geht nicht nur für Bauteile, sondern auch für Pads, Leiterbahnen ec. Siehe: http://www.mikrocontroller.net/topic/178816#new

=== Layout: Python Scripting ===

Das Python2-Scripting ist bisher nur in PCBnew implementiert und noch sehr experimentell. Daher ist leider auch der aktuelle Stand der Dokumentation zum Python-Skripting in PCBnew noch etwas dürftig. Trozdem hier Links dazu:
* http://www.kicad-pcb.org/display/KICAD/KiCad+Scripting+Reference+Manual (Allgemein. Achtung! Kicad braucht beim compilieren spezielle Befehle, um Python-Scripting tauglich zu sein.)
* http://dev.kicad-pcb.org/doxygen-python/index.html (Definitionen von Namespaces, Classes und Files)

Für Linux-Debian:
Aktuell (07. Februar 2014) mit Pcbnew Version: (2014-01-27 BZR 4641)-product Release build auf
Platform: Linux 3.2.0-4-686-pae i686, 32 bit, Little endian, wxGTK (Debian Wheezy) gilt:
* Geht aktuell nur für PCBnew.
* Klassenbibliotheken: Zwei Dateien pcbnew.py und _pcbnew.so auf dem Pfad: /usr/lib/python2.7/dist-packages/
* Die Klassenbibliothek wird mit den üblichen Python2 Methoden importiert: z.B. "import pcbnew" oder "from pcbnew import *"

Beispielprogramm, das alle Footprints aus einer Legacy-Fotprint Datei auflisted und den Referenzbezeichner dazuschreibt::
<pre>
#!/usr/bin/env python
# das war das Shebang.

from pcbnew import * # Import der Bibliothek.
libpath = "/home/DuUser/KiCad-Daten/Module/ModuleGrosserSampler/KiCadLegacyFottprints.mod" # Übergabe des Pfades.
lst = FootprintEnumerate(libpath)
for name in lst:
m = FootprintLoad(libpath,name)
print name,"->", m.GetReference()
</pre>

Die Scripting Möglichkeit ist so neu, dass bis jetzt die Scripting Testdateien für das KiCAD interne automatische Qualitätssicherungssystem noch nicht komplett sind.
Unter http://bazaar.launchpad.net/~kicad-product-committers/kicad/product/files/head:/qa/testcases/ finden sich bereits geprüfte Testskripte, und unter http://bazaar.launchpad.net/~kicad-product-committers/kicad/product/files/head:/pcbnew/scripting/examples/ finden sich ungetestete Testskripte.

Sie alle können als Beispiele genommen werden, wie das mit dem Skripting gemeint ist, und als Vorbild für eigene Skripte dienen.

=== Module Editor ===
* Wie erstellt man Footprints für Bauteile?
** Mit dem Footprint Editor. Er ist bei älteren KiCad Versionen nur aus PCBnew heraus zu starten. Bei neueren KiCad Versionen hat er einen eigenen Button im KiCad Start Window.
** Spezielleres: http://www.mikrocontroller.net/topic/356151#new
* Wie verbinde kopiere ich etwas aus einem Footprint in einen anderen hinein, bzw. wie verbinde/merge ich zwei Footprints?
** http://www.mikrocontroller.net/topic/288167#3061997
* Kann man im Module Editor die Eigenschaften aller Pads gleichzeitig ändern?
** http://www.mikrocontroller.net/topic/93131#799550
* Ich brauche einen Footprint, bei dem mehrere Pads verbunden sind, will aber nicht im Schaltplan zig Pins aufführen und anschliessen müssen.
**http://www.mikrocontroller.net/topic/208982#new
**http://www.mikrocontroller.net/topic/204717#new
* Wie erzeugt man thermal Vias in Kicad?
** Leider bisher nur experimentell: http://www.mikrocontroller.net/topic/298028#3187259
* Wie kann man Bauteilmaße in in den Ansichten (Footprint, Layout, 3D-View) anzeigen?
* Wie verwalte ich Footprint Bibliotheken?
** Indem man sich ein Board erstellt, alle Footprints, die man zusammenfassen möchte, auf das Board stellt, und dann untet Dateien > Footprints archivieren > Footprint Archiv erstellen wählt. Das so erstellte Board kann auch zu Dokumentationszwecken geplottet werden. Eventuell möchte man einige Footprints, die zu Hilfszwecken (z.B. Skalen) auf dem Board sind, anschliessend mit dem Bibliothekseditor daraus löschen.
** Alternativ, im dem "neuen" *.pretty Format, mit einem Dateiverwaltungsprogramm Deiner Wahl. Siehe http://www.mikrocontroller.net/topic/320301#new
* Wie werden die Parameter für Lötpaste/Lötstopmaske vergeben?
**http://www.mikrocontroller.net/topic/356151
* Ich möchte für einen Footprint Pads in einem Gittermuster/Array oder im Kreis anordnen. Gibt es dafür automatische Hilfestellungen?
** Ja. Pad rechts anklicken. Eventuell erfolgt noch eine Feinauswahl. Dann im aufpoppenden Menue "Array erstellen" wählen.

=== 3D-Ansicht ===
* Die 3D-Ansicht funktioniert bei mir nicht.
** http://www.mikrocontroller.net/topic/289075#new
* Kann man die 3D-Ansicht in ein 3D-CAD Programm exportieren?
**http://www.mikrocontroller.net/topic/203388#new
* Wie kann man Bauteilmaße in in den Ansichten (Footprint, Layout, 3D-View) anzeigen?

Da KiCAD in Punkto 3D-Ansicht komplett auf Wings3D beruht, und die 3D Modelle der Bauteile wrl-files sind, die mit Wings3D (oder Blender) erstellt werden können, sei hier auf ein Wings3D Handbuch verwiesen: http://www.oortman3d.com/wings3d/TheWings3dHandbook.pdf

Viele Bauteilhersteller (vor allem von eher mechanischen, wie z.B. Stecker, Buchsen, Befestigung...) bieten fertige 3D-Modelle an. Diese sind meistens in den Formaten STEP oder IGES. So kann man diese in das von KiCAD benötigte .wrl (VRML 2.0) konvertieren:
# STEP oder IGES in [http://gcad3d.org/ gCAD3D] öffnen (File > Open Model)
# als Wavefront .obj speichern (File > Save Model as > OBJ)
# Das .obj in [http://www.wings3d.com/ Wings 3D] importieren (File > Import > Wavefront .obj)
# Als VRML 2 exportieren (File > Export > VRML 2.0 .wrl)
# Im KiCAD-Moduleditor die .wrl-Datei als 3D-Modell auswählen
# Eventuell muss man die Skalierung und Positionierung anpassen, die angezeigten Pads und Löcher helfen dabei. Die am meisten benötigten Faktoren dürften dabei 0,3937 und 2,54 sein - bei den Konvertierungen kommt leicht die Einheit Zoll oder cm durcheinander.

Eine andere Möglichkeit .obj oder .stl-Dateien aus STEP und IGES zu erzeugen ist [http://free-cad.sourceforge.net/ FreeCAD]. Obwohl es auch .wrl direkt erzeugen kann, können diese nicht in KiCAD geladen werden. Der Umweg über .obj oder .stl und Wings 3D löst dies aber auch hier.

Wenn man das Board wieder in einem CAD-Programm verwenden will um z.B. ein Gehäuse zu konstruieren, sollte man wieder STEP-Dateien erzeugen. Neuere KiCAD-Versionen können zwar VRML exportieren, doch das beschreibt nur Umrisse und keine Körper (Solids). CAD-Programme zum Gehäusedesign brauchen jedoch letzteres. So geht die Konvertierung:
# VRML aus KiCAD exportieren (File > Export > VRML)
# .wrl-Datei mit Hilfe von [http://www.cs.princeton.edu/~min/meshconv/ meshconv] in eine STL-Datei konvertieren: <code>meshconv boardname.wrl -c stl -o boardname.stl</code>
# Die STL-Datei mit [http://www.solveering.com/products/products_stl2step.html stl2step] in eine STEP-Datei konvertieren

Man sollte hinterher im CAD nochmal genau die Maße kontrollieren. Denn die Konvertierung von STL nach STEP ist nur eine Approximierung und keine exakte, verlustfreie Konvertierung.

*Und wie bedient man Wings3d?
** Ein (vorläufiger) Merkzettel/Ultrakurzanleitung zur Bedienung von Wings3D findet sich hier: [[Media:Kicad-Wings3D_Merkzettel_29November2012.pdf]]. Wenn man nur mit Wings3d Modelle für Kicad erstellen will, langt das eventuell schon als Tutorial. There is also an English translation of this leaflet about using wings3d for kicad at [[Media:Kicad-Wings3D_Leaflet_25April2013.pdf]].

=== Drucken/Plotten/Gerber Export/Excellon Drillfiles Export ===

==== Drucken ====
* Wie exportiert man den Schaltplan oder das Layout als Bild (PNG o.ä.)?
** Drucken über Postscript-Treiber und Umwandeln mit Ghostscript
** [http://www.mikrocontroller.net/topic/96060#1061492]
** Plot to Clipboard [http://www.mikrocontroller.net/topic/117562#1056566]
* Wie kann ich GENAU ausdrucken? Mein Ausdruck auf ABC ist ca. X % zu klein oder Y% zu groß!
** So genau sind einfache Drucker bzw. Druckertreiber selten. Aber meistens hilft folgendes: Mache einen 1:1 (100%) Probeausdruck. Messe auf dem Ausdruck nach, wie groß er tatsächlich geworden ist. Berechne die Abweichung und gebe sie in den Drucker bzw. Druckertreiber unter Einstellung ein, vorausgesetzt, der Drucker bzw. Druckertreiber kann das. Mit dem Wert machst Du wieder eine Probeausdruck, messe wieder nach, und wenn es mit der Einstellung funktioniert hat, kannst Du Deine Folie bedrucken. Wenn das nicht klappen kann, weil Du stark abweichende Werte für horizontal und vertikal bräuchtest, aber der Drucker nur einen gleichen Wert für beides kennt, hast Du einen (zu) schlechten Drucker. Trozdem nicht verzweifeln, weil KiCAD beim Drucken oder Plotten in der X- und Y-Achse getrennt skalieren kann. Aber Vorsicht bei Weitergabe der so erzeugten Dateien: Sie sind individuell auf einen Drucker angepasst, und produzieren auf einem anderen Drucker nur falsch skalierte Ausdrucke. Weil der Wert von Drucker zu Drucker unterschiedlich ist, ist es auch sinnvoll, diese Skalierung direkt am speziellen Drucker/Druckertreiber zu machen. Tipp: Wenn Du den Wert erfolgreich ermittelt hast, so kleb Dir einen Zettel auf den Drucker mit dem Wert. Die Werte sind zwar individuell für jeden Drucker, aber meistens für den speziellen Drucker durchaus fix. Und Du hast ihn sofort wieder parat, wenn der Drucker resettet wurde. Dies ist übrigens ein allgemeiner Tipp für das Ausdrucken, der auch für Eagle, Target, Altium usw. gilt.
** Thema Skalieren - Die aktuelle Situation (August 2013): http://www.mikrocontroller.net/topic/304619#new
** Und nochmal Thema Skalieren: http://www.mikrocontroller.net/topic/371079#4191106
* Wie kann man das Layout invers ausdrucken, d.h. alle Leiterbahnen und Pads müssen weiß bleiben, der Rest wird schwarz ausgedruckt?
** Beim Plotten den Haken bei Negativ-Plot setzen [http://www.mikrocontroller.net/topic/156202#1474507]
* Ich habe irgendwie Probleme mit dem Ausdrucken.
** Verzerrt: http://www.mikrocontroller.net/topic/207764#new
** Sonderzeichen: http://www.mikrocontroller.net/topic/207310#new
** In der aktuellen Version 2012-01-19 BZR 3256)-stable besteht ein generelles Druckproblem. Aber Plotten geht wunderbar!
** Aktualisierter Stand 23. Dezember 2012: http://www.mikrocontroller.net/topic/280958#new
** Aktualisierter Stand vom 21. Juli 2013: http://www.mikrocontroller.net/topic/303043#3249166

* Ich würde gerne PDF Dateien aus meinem Layout erstellen, aber irgendwie ist der Ausdruck defekt.
** Drucken ist aus Kicad manchmal ein Problem, auch in eine Datei hinein. Aber Plotten und Exportieren in SVG funktioniert gut. Von SVG zu PDF kommt man über Inkscape. Siehe hier: http://www.mikrocontroller.net/topic/303043#3249166
* Wie kann ich mir einen Bohrplan ausdrucken, um mit der Hand zu bohren?
**http://www.mikrocontroller.net/topic/266037#new

==== SVG Plotten ====

* Meine erzeugten SVG Plots sind kaputt. Ich erhalte nur Fehlermeldungen, wenn ich sie in Inkscape oder Gimp einlesen will.
** Es besteht ein Problem mit dem SVG Export, wenn man Schaltpläne oder Boards in SVG exportiert, die ein Ampersand (Kaufmansund, "&") im Dateinamen haben. Dieser Dateiname tauch dann innerhalb der SVG Datei in einem Titelblock auf, wo das "&" dann ein Problem bedeutet (Es leitet eine Art Escape-Sequenz ein). Sowohl Kicad als auch Inkscape/Gimp aktzeptieren "&" im Dateinamen, und sowol unter Windows als auch Linux ist das "&" im Dateinamen legal....darum bringt auch eine Veränderung des Namens der SVG-Datei keine Lösung. Eine Lösung ist, Grundsätzlich in Kicad keine "&" in Dateinamen zu verwenden, wenn man einen SVG-Export macht. Alternativ kann man mit einem Editor das "&" aus dem Titelblock (Das ist NICHT der Dateiname, sondern in der Datei selber alles zwischen <titel> und </titel>) der SVG-Datei löschen. Angeblich kommt der Bug aus den verwendeten wx-Bibliotheken. Siehe den Bugreport: https://bugs.launchpad.net/kicad/+bug/1171160

==== Gerber Export ====

* Kann man Gerber-Dateien exportieren?
** Ja. Es wird extended Gerber 247X exportiert. Einheit ist inch (doppelt sowohl im 247d als auch im 247x Stil definiert). Die Y-Koordinaten sind im allgemeinen negativ. KiCAD verwendet für Flächen das in Gerber spezifizierte Polygon Makro und kein "stroke fill".
** Um Gerber Dateien zu erstellen, wählt man aus der oberen Menueleiste ganz links Datei > Plotten und dann oben links unter Plotformat "Gerber"
** KiCad unterstützt auch die kürzlich eingeführten Gerber-Attribute. Die Anwendung derselben muss aber explizit angewählt werden. Dazu setzt man im Gerber-Plottmenue im Feld "Gerber Optionen" bei "include extended attributes" einen Haken.
** KiCad kann automatisch die Lötstoppmaske von der Siebdruckmaske (Silk screen - Bestückungsaufdruck) abziehen, damit nicht der Bestückungsaufdruck versehentlich über Pads liegt und dort das Löten verhindert. Dazu muss aber im Gerber-Plottmenue im Feld "Gerber Optionen" bei "Subtrahiere Lötstoppmaske von Siebdruckmaske" ein Haken gesetzt werden.
* Wie kann man den Gerber-Plot so ausdrucken, dass in der Mitte von Pads und Vias ein Zentrierloch frei bleibt?
** http://article.gmane.org/gmane.comp.cad.kicad.user/3457

==== Excellon Drillfiles exportieren ====

* Wie erstelle ich mit KiCad Excellon Drillfiles?
**siehe hier: http://www.mikrocontroller.net/topic/310333#new

==== KiCad Board Dateien direkt zum Hersteller ====

* Bei Bestellungen bei PCB-Pool ist deren GC-Prevue NICHT mehr erforderlich, weil PCB-Pool mittlerweile KiCAD *,brd Dateien direkt aktzeptiert. Siehe http://www.pcb-pool.com/ppde/info_dataformat.html Das gilt auch für viele andere Hersteller. im Zweifel dort einmal nachfragen.

* '''Trotzdem''' sollte man '''besser Gerber Dateien''' zum Platinenhersteller senden. Das gilt '''grundsätzlich''' so auch für andere Platinen Layout Programme. Der Grund ist hier angegeben: https://www.mikrocontroller.net/wikisoftware/index.php?title=Gerber-Tools&action=edit&section=8

=== Import ===
* Kann man EAGLE Dateien importieren? (=> Obacht bei Weitergabe der Daten!)
** http://www.mikrocontroller.net/topic/70905#797416
** http://www.mikrocontroller.net/topic/120373#1089933
** Aktuell: http://www.mikrocontroller.net/articles/KiCAD#Konverter
* Wie bindet man fremde KiCAD Bibliotheken ein?
** EESchema (Schaltplaneditor) starten, unter Einstellungen "Bibliothek" auswählen, auf "Hinzufügen" klicken, neue Bibliothek auswählen dann "öffnen" und in der Projektdatei "Speichern". Gültig für Version 20090216Final, 2011-04-29-BZR2986-WinXP und Version: (2011-11-27 BZR 3249)-stable unter Platform: Linux 2.6.32-5-686 i686, 32 bit, Little endian, wxGTK.

** VERALTET! Das Verfahren zur Einbindung eigener oder fremder Bibliotheken ist under PCBnew genauso.
** Aktuell: Siehe http://www.mikrocontroller.net/topic/356855#3988114
Es empfielt sich dringenst, eigene Bibliotheken NICHT zu den KiCAD Bibliotheken im Ordner kicad/share/library bzw. kicad/share/modules für Footprints zu speichern, weil diese dort bei einem Upgrade gelöscht würden. Stattdessen sollte man sich einen kicad Ordner im eigenen home bzw. Benutzerverzeichnis (oder sonstwo, wo es opportun ist, und man Schreibrechte hat) anlegen, mit einem Ort, um eigene Bibliotheken abzulegen.

=== Neues Projekt ===
Ein neues Projekt legt kicad automatisch nach der in kicad/share/template hinterlegten Projektdatei an. Möchte man, das kicad ein neues Projekt von vorneherein nur mit ausgewählten eigenen Bibliotheken anlegt, so ist eine entsprechende Projektdatei unter kicad/share/template/kicad.pro abzulegen.
Dies erfordert dort Schreibrechte. Linux roots müssen diese Datei anschliessend mit chmod 755 Dateiname für user lesbar machen.
Bei einem upgrade würde kicad.pro gelöscht. Daher sollte man sich davon eine Sicherheitskopie in seinem benutzerverzeichnis hinterlegen.

=== Einstellungen sichern / wiederherstellen===
* Wo speichert KiCAD die Einstellungen ab und wie lassen sich die originalen Einstellungen wiederherstellen?
** [[http://kicad.sourceforge.net/wiki/index.php/DE:KiCadHB#Einstellungen_sichern_.2F_wiederherstellen]]
**Man erstelle ein neues Projekt beliebigen Namens, nehme alle Einstellungen (Bibliotheken, Pfade usw.) vor und speichere diese in der aktuellen Projektdatei "name.pro". Im Ordner KiCAD Verzeichnis ....../kicad/share/template befindet sich eine Datei "kicad.pro". Diese Datei "kicad.pro" ist die "Musterprojektdatei", die für alle neuen Projekte verwendet wird. Man benenne sie um in "kicad-orig.pro, und kopiere die aktuelle Projektdatei "name.pro" nun als "kicad.pro" in diesen Template-Ordner. Leider Funktioniert dieses Verfahren nicht in allen KiCAD Versionen. Den originalen Zustand stellt man wieder her, indem man "kicad.pro" umbenennt, und "kicad-org.pro" wieder in "kicad.pro" zurückumbenennt.

=== Bitmaps als Symbol oder Footprint importieren ===
Der Programmteil Bitmap2component wandelt Bitmaps wahlweise in Symbole oder in Footprints um. Auf diese Weise können also auch Logos oder spezielle Muster für HF-anwendungen in KiCAD importiert werden, sobald sie als Bitmap vorliegen. Diese Funktion ist allerdings sehr neu (im Frühjahr 2011 eingefügt) und eher als experimentell zu bezeichnen. So funktioniert z.B. der Export in ein Symbol in der Version BZR-2986 NICHT.

== Tipps&Tricks / Eigenheiten / Bugs ==

* Nachbearbeitung mit Skript oder Texteditor (Pin Swapping, Versionskontrolle via SVN, Generierung von Packages aus UCF-Listen)
** http://www.mikrocontroller.net/topic/120373#1100467
** http://www.mikrocontroller.net/topic/96860#836967
** http://stawoo.com/dokuwiki/doku.php?id=ecld:kicad:board

* Veraltet! (2006) Schaltplan: Durchnummerieren von GND und PWR erforderlich http://www.mikrocontroller.net/topic/39243#290309

* Zum Verbinden von Schaltplan und Layout müssen an den Bauteilen die Pinnummern mit den Padnummern der Footprints korrespondieren. Das ist "defaultmäßig" nicht immer zu erreichen, weil es unterschiedliche Nummerierungssysteme gibt. Ausser dem Anlegen eines speziellen Footprints kann diese Anpassung für einzelne Bauteile wärend des Layoutens im Moduleditor vorgenommen werden. http://www.mikrocontroller.net/topic/186121#1805890
* Ich habe einen hierarchischen Schaltplan angefertigt, indem sich eine Schaltung zig mal wiederholt. Eine dieser Subschaltungen habe ich schon geroutet, und möchte dieses Layout genau wie die hierarchischen Schaltpläne mehrfach auf dem Board verwenden.
** In PCBnew lassen sich mit "Datei>Platine hinzufügen" auch schon geroutete Gruppen von Bauteilen quasi als Modul einfügen, wenn sie zuvor als Board abgelegt wurden. Ebenso kann eine Bauteilgruppe, die in der Form mehrmals vorkommt, und die die schon einmal geroutet worden ist, gruppiert, kopiert und wiederverwended werden. Die dazu nötige Annotation und das Löschen der überzähligen Bauteile muss aber sorgfältig von Hand gemacht werden. '''Anmerkung:''' In neueren Versionen von PCBnew ist diese Funktion ausgegraut, wenn PCBnew "normal" aus dem Menue des KiCad Hauptfensters gestartet wurde. Um diese Funktion zu aktivieren, KiCad schliessen und PCBnew wie ein alleinstehendes Program direkt starten.
** Wer seinen Subschaltplan separat routen möchte, sollte den Subschaltplan explizit in EEschema öffnen und die Netliste nur dieses Subschaltplanes exportieren. Diese Netlist in ein neues Board in PCBnew einlesen und wie üblich routen.
* Bibliotheken verwalten, umsortieren bzw. neu strukturieren: http://www.mikrocontroller.net/topic/187107#1817559

* Layout: Rest-Gummiband an Pins http://www.mikrocontroller.net/topic/120373#1092375

* Produktion: http://www.mikrocontroller.net/topic/98034#848965

* Bug in Version 2010-03-14: Unter Einstellungen lässt sich keine einseitige Platine wählen (wichtig für Autorouter). Lösung: Modifikation des .brd Files mit einem Editor [http://www.mikrocontroller.net/topic/172015#1651239]:

:<pre>
:In der *.brd Datei gleich ganz oben...
:
:$GENERAL
:LayerCount 2 -> auf 1 setzen
:
:$SETUP
:InternalUnit 0.000100 INCH
:ZoneGridSize 250
:Layers 2 -> auf 1 setzen
:Layer[0] Rückseite power
:Layer[15] Vorderseite power -> hab' ich mal beides so gelassen
:</pre> aktueller: http://www.mikrocontroller.net/topic/172015#1794699

* Das Anlegen von Symbolen/Bauteilen in aufgelöster Darstellung ist etwas stolperig. Siehe: http://www.mikrocontroller.net/topic/294095#3136180

* Es empfielt sich, in Kicad vorläufig KEIN Ampersand (Kaufmansund, "&") im Namen einer Schaltplan- oder Boarddatei zu Verwenden. Es besteht ein Bug beim Export/Plotten nach SVG. Siehe oben unter "Drucken / Export" und dann "Meine erzeugten SVG Plots sind kaputt.". Siehe auch: http://tech.groups.yahoo.com/group/kicad-users/message/14952

* '''Kühlkörper''' können als Symbol und Footprint (Modul) angelegt werden. Die Befestigungslöcher können im Modul als Pad ausgeführt werden. Die Padnummer aller Pads sollte gleich sein (gleicher Anschluss / über Kühlkörper verbunden), z.B. "1". Entsprechend ein Symbol mit Pin und korrespondierender Pinnummer anlegen. Wenn der Kühlkörper elektrisch nirgendwo verbunden sein soll, dann die Anschlusspinne im Schaltplan als "unused" markieren. Als Referenz in Symbol und Footprint habe ich "HS" (HeatSink) gewählt. Es ist zu überlegen, ob "HS" nicht auch als Padnummer besser wäre.

* '''Kartenumrisse/Outlines''': Für immer wiederkehrende Platinengrössen, z.B. die beliebte Eurokarte, kann zur Vereinfachung des Zeichnens einmal ein Eurokartenumriss im Layer "outlines" gezeichnet werden, und als Modul abgelegt werden. Um die Zahl der Kollisionen beim Einlesen der Netzliste zu verringern, wird im Schaltplan ein Dummy-Symbol ohne Pinne angelegt. In CVpcb dann dieses Symbol mit dem passenden Kartenumriss Footprint/Modul verbinden, und es wird automatisch in PCBnew eingefügt. Als Referenz in Symbol und Footprint habe ich "Outl" (OUTLine) gewählt.

* '''Sprachanpassung''': Ich will mein KiCAD auf Deutsch / Englisch / Französisch / Finnisch oder sonst eine Sprache umstellen. Wie geht das?
** Siehe : http://www.mikrocontroller.net/topic/262039#2719056
**Die deutsche Übersetzung der Texte und Hilfetexte/Tooltips ist manchmal etwas unelegant. Wem so etwas auffält, bitte Mitteilung am Ende dieses Threads: http://www.mikrocontroller.net/topic/255932#2641638 (deutschsprachig) oder an die KiCAD user group unter https://groups.yahoo.com/neo/groups/kicad-users/info (englischsprachig, auch bei Fällen wo es um die deutsche Übersetzung geht). Diese Mitteilungen nach Möglichkeit nicht in Launchpad.
** Ich habe aber keine Möglichkeit, die Sprache umzustellen!
*** Wenn Debian eine Fehlermeldung "Cannot set locale to 'xy_XY'. kommt, ist die entsprechende Umgebung nicht installiert. Unter Debian als root in der Konsole: "dpkg-reconfigure locales" aufrufen. Es öffnet sich eine ncurses-gui, wo die entsprechenden Einstellungen gemacht werden können. Für "Deutsch" wähle ich "de_DE.utf8".
*** Wenn nichts passiert, fehlen möglicherweise die localisierungs Dateien. Sie sind NICHT Teil der Sourcen, und finden sich in http://bazaar.launchpad.net/~kicad-developers/kicad/doc/files/head:/internat/. Auf Debian und verwandten Systemen müssen die einzelnen localisationsordner, z. B. "de" nach /usr/local/share/kicad/internat kopiert werden. Dann als root dort Leserechte erteilen mit "chmode -R 755 /usr/local/share/kicad/internat".
*** Wenn ein Mischmasch aus Englisch und der gewählten Sprache existiert, sind entweder nicht alle Begriffe übersetzt (siehe oben) oder wegen Umbenennung von Variablen ist eine Inkonsistenz entstanden. Siehe: http://www.mikrocontroller.net/topic/326622#3565178
** Für die KiCad Localsisation wird "GNU gettext" verwendet. Eine kleine Hilfestellung zur Anpassung der Localisation findet sich hier: http://dev.kicad-pcb.org/docs/GUI_Translation_HOWTO.pdf. Info zu Gnu gettext findet sich hier: http://de.wikipedia.org/wiki/GNU_gettext

* '''Projektdateien (.pro) Pfadschreibweise''': In einer Windowsumgebung ist es anscheinend nötig, relative Pfade speziell zu kennzeichnen. Siehe: http://www.mikrocontroller.net/topic/326869#new

=== Problem: Der Ursprung für die Pick und Place bzw. Drill-Daten wurde verändert und lässt sich nicht zurücksetzten. ===
Siehe: http://www.mikrocontroller.net/topic/363280#new

=== Problem: Case Senitive Symbols ab BZR4646 (Jan./Feb. 2014) ===
Ab BZR4646 sind die Symbole in Eeschema "Case Sensitive". Das bedeutet: In alten Schaltplandateien wurden für die Symbolnamen nur Großbuchstaben verwendet, auch wenn die Originalnamen in der Library Kleinbuchstaben enthielten. Ab BZR4646 werden die Symbolnamen in den Schaltplandateien genauso geschrieben wie die Originalnamen in der Library. Leider werden dadurch bei alten Schaltplandateien die großgeschriebenen Symbolnamen nicht mehr in den Bibliotheksdateien erkannt. Auch nicht in den "-cache.lib" Dateien. Ganz so kritisch, wie es sich anhört, ist es wiederum auch nicht, weil KiCad schon seit geraumer Zeit die Schaltpläne in der neuen Version speichert. Jemand, der mit aktuellen KiCad Versionen an aktuellen Schaltplänen arbeitet, wird darum den Übergang vermutlich nicht bemerken. Allerdings tritt das Problem bei alten Schaltplänen auf, die möglicherweise Jahrelang unberührt auf der Festplatte lagen. Um die Symbolnamen in diesen alten Schaltplandateien anzupassen, existiert das Python3 Skript "PyKiCad-CaseSensitiveLibCure_RevD_13Apr2015.zip". Es ist ein "Stand alone" Python3 skript, das nicht in das KiCad interne Python skripting eingebunden ist. Die Datei kann hier bezogen werden:[[Media:PyKiCad-CaseSensitiveLibCure_RevD_13Apr2015.zip]].
Autor: Bernd Wiebus, GNU-GPL.

Be einigen Linux Distributionen wird neben Python 3 auch noch das Paket "python3-tk" benötigt.
Sonst gibt es die Fehlermeldung "ImportError: No module named tkinter"

Manueller Start mit: "python3 PyKiCad-CaseSensitiveLibCure_RevD_13Mar2015.py"

Dieses Skript kann benutzt werden, um Schaltpläne, die mit der Eeschema Version (2013-11-29 BZR 4513) von Ende 2013, die in Linux Repositorys (z.B. Debian 7 "Wheezy") noch sehr verbreitet ist, auf aktuelle KiCad Versionen anzupassen.

=== Problem: Backporting KiCad-Board Dateien (.kicad_pcb) von Version 5 auf Version 4. 2014/2015) ===

Möchte man z.B mit einer KiCad/PCBnew Version BZR 4027 vom 22 Juni 2014, welche in vielen Repositorys noch weit verbreitet ist, eine Board-Datei ( .kicad_pcb), die mit einer neueren PCBnew Version erstellt wurde, z.B. einer BZR 5513 vom 14. März 2015 (die aktuell kompiliert wurde), öffnen, so stösst man auf Probleme. Aktuell die BZR 5513 verwendet für die Board Dateien Version 5, und die alte BZR 4027 verwendet dort die Version 4. Obwohl das Schema der Boarddateien fast gleich ist, enthält die Version 5 Elemente, die es zur Zeit der Version 4 noch nicht gab, und die darum zu Fehlermeldungen und zum Abbruch des Einlesens der Datei führen. Diese Neuerungen beziehen sich auf den Export von Gerberfiles mit Attributen sowie Platinenlagen, die es vorher noch nicht gab. Diese Fehler sind dank der einfachen, klarschriftlesbaren Filestruktur von KiCad sehr leicht mit einem Texteditor zu beheben. Eine Beschreibung, wie dieses manuell zu machen ist, finden Sie hier: [[Media:KiCad-PCBnewBoardDateienMigrierenVonVersion4Auf5.pdf]]

=== Tipps&Tricks: Building Blocks ===
* Eine unfertige Dokumentation, wie man das hierarchische Schaltplansystem von KiCAD verwendet, um daraus schnell und rationell Schaltpläne mit vorgefertigten Schaltplänen (Building Blocks) nach dem Baukastensystem aufzubauen. Enthält auch ein Beispielprojekt. Beachte die Liesmich.txt Datei. [[Media:BuildingBlocksKiCAD-EXPERIMENTELL.zip]] Das File KiCAD-HierarchischeSchaltplaene+buildingBlocksRevA_Vorlaeufig.pdf, enthält eine vorläufige Beschreibung dazu. KiCAD-HierarchischeSchaltplaene+buildingBlocksRevA-EN.pdf is an English description how to use hirarchical schematics as building blocks for a fast and rationel schematic design. Es fehlt noch die Übersetzung und die Bebilderung und ein paar Berichtigungen und Ergänzungen. ;-) . Das echte Hauptbeispielprojekt ist UnderVoltageDetector24V-2Group_Experimental.pro bzw. UnderVoltageDetector24V-2Group_Experimental.sch. Im Ordner Experimentalprojekt23052010 findet sich ein weiterer Ordner BuildingBlocksExperimental. Dieser enthält die Ausgangsbausteine VoltageRegulatorBuildingBlock.sch mit VoltageRegulatorBuildingBlock-cache.lib und VoltageDetectorBuildingBlock.sch mit VoltageDetectorBuildingBlock-cache.lib. Die Projektdateien der Buildingblocks .pro sind nur der Vollständigkeit und zur leichteren Bearbeitung zugefügt. Aus VoltageDetectorBuildingBlock.sch und VoltageRegulatorBuildingBlock.sch wurde (nach umkopieren, umbenenen und kleiner Änderung) im übergeordneten Ordner das Projekt VoltageRegulatorBuildingBlock.pro unter verwendung des "Zwischenbuildingblocks" UnderVoltageDetectorBuildingBlock.sch zusammengesetzt. NICHT VERGESSEN DIE CACHE.LIB EINZUBINDEN! Sonst gibt es nur Fragezeichen statt Bauteile. Das Beispielprojekt enthält eine 24V Unterspannungsüberwachung für einen Bleiakku, die zwei 12V Gruppen überwacht. Nicht elegant, aber hoffentlich robust. Autor: Bernd Wiebus , GNU-GPL. Der dazubezügliche Beitrag im Forum ist: http://www.mikrocontroller.net/topic/178683#1724114
*[[Media:HierarchischeSchaltplaeneAlsBausteineInKicad_RevC_23Dec2013.pdf]] VERBESSERTE und AKTUALISIERTE Version von KiCAD-HierarchischeSchaltplaene+buildingBlocksRevA_Vorlaeufig.pdf aus obiger Zip-Datei. Beschreibt, wie mit Hilfe der hierarchischen Schaltplanstruktur aus einzelnen, vorgefertigten Schaltplänen schnell und rationell neue Schaltpläne modular zusammengesetzt werden können. There is also a English translation of this tutorial about using hierarchical schematics as building blocks. You can get it here: [[Media:HierarchicalSchematicsAsBuildingblocksAtKiCad_RevC-EN_06May2015.pdf]]
* Eine Sammlung von gängigen Schaltungen mit den Längstreglern LM317 /LM78xx /LM79xx und dem Timer 555, die nach dem in obig erwänten Dokument KiCAD_HierarchischeSchaltplaene+buildingBlocksRevA_Vorlaeufig.pdf beschriebenen Vorgehen als Building Blocks in KiCAD verwendet werden können, findet sich unter: http://www.mikrocontroller.net/articles/KiCAD#Building-Blocks

=== Tipps&Tricks: Lochraster Platinen Entwurf mit KiCad ===

Wer viel mit Lochraster Platinen arbeitet, hat gelegentlich auch ein Bedürfnis, diese Tätigkeit mit einem Layoutprogramm zu begleiten. Zum einen um den Platzbedarf besser abschätzen zu können, zum anderen, um dadurch auch eine schnelle und einfache Dokumentation auch für Lochrasterprojekte zu schaffen. Auch dazu kann KiCad verwendet werden.
* Vorgehensweise: Schaltplan in Eeschema erstellen wie üblich, Netzliste erzeugen, und in CVpcp die Bauteile zuordnen. In PCBnew dann das Raster einblenden und auf 2,54mm (100mil) stellen. Nun geben die Rasterpunkte die Position der Löcher der Lochrasterplatine vor. Nach dem Einlesen der Netzliste bei Lochraster mit Streifenleitungen am besten zweiseitig manuell routen. Auf der Unterseite der Richtung der Streifenleitung in Längstrichtung folgen (z.b. wagerecht). Auf der Oberseite die Brücken dazu quer legen (z.B. senkrecht). Zweipolige Bauteile immer senkrecht oder wagerecht positionieren. Dieses Verfahren geht grundsätzlich mit jedem Layoutprogramm, das ein Raster anzeigen kann.
** Wer eine Platine erstellen möchte, die nur teilweise ein Lochraster aufweist, dem sei diese Diskussion empfohlen: https://www.mikrocontroller.net/topic/369534#new

=== Tipps&Tricks: KiCad und Freeroute ===
Leider ist die Freeroute Seite abgeschaltet. Grund:http://www.mikrocontroller.net/topic/337014#new Allerdings gibt es eine Möglichkeit, Freeroute selber zu installieren und zu nutzen: https://github.com/nikropht/FreeRouting und http://freerouting.net/index_de.php
*Freerouting einseitig bzw. für Lochraster verwenden: http://www.mikrocontroller.net/topic/363335#new

=== Tipps&Tricks: KiCad und Specctra Autorouter ===
Es treten beim Export der Netzlisten/Designs Fehlermeldungen der Art: "IO_ERROR: Multiple components have identical reference IDs" auf, obwohl offensichtlich keine doppelten Referenzbezeichner vergeben wurden.
* Die "doppelten Referenzbezeichner" sind doch "irgendwie" versteckt vorhanden. Z.B. dadurch, das Bauteile nicht Referenziert oder Annotiert wurden. Im Zweifel die Files mit einem Texteditor danach durchsuchen, oder die Autoannotation über das Board laufen lassen. Siehe: https://www.mikrocontroller.net/topic/365185#new

== Bibliotheken ==

In diesem Abschnitt sollen unsere Arbeiten an Bibliotheken koordiniert werden. Dabei sollen alle Arbeiten unter der Creative Commons Lizenz stattfinden. Das heisst insbesondere, dass keine Arbeiten mit anderem Copyright unseren Bibliothekspool vergiften sollen z. B. durch unerwünschte Konvertierung von EAGLE-Bibliotheken.

Unsere Designziele sind:
* Frei benutzbar (Creative Commons Lizenz)
* Einheitlich (Richtlinien?)
** Vorschlag von Marko für Bohrungen und Pads siehe [http://www.mikrocontroller.net/topic/124070#1176177]
** Die Richtlinien, die die KiCad Librarys selber verwenden: [https://github.com/KiCad/kicad-library/blob/master/KiCad_Library_Convention.txt]
* Fehlerfrei (Nachkontrolle durch andere User)

=== Wünsche ===

Hier soll eine Strichliste geführt werden, welche neuen Bauteile gesucht sind bzw. welche oder besseren, genaueren Versionen benötigt werden. Bitte gebt an, was bei bestehenden Bauteilen problematisch ist.

Bevor wir Bibliotheken erstellen, sollten auf jeden Fall einige Parameter - insbesondere für die Schaltplansymbole - festgelegt werden: Pinlänge, Pinabstand, Größe der Schriften, Konventionen bzw. Nummerierung (z.B. bei gepolten Bauteilen wie Dioden, Elkos usw.). Sonst entsteht Wildwuchs, weil jeder für sich anderes festlegt.

* Stehende Layouts für 7805 und N-FETs: ||||
** Passt TO220_VERT ? Natürlich! Nur die Anschlussnumerierung muss ev. passend adaptiert werden. Ist unter "TO-220" in [[Media:KiCAD_Module_Footprints_3D_29Aug2014.zip]] enthalten. In allen Perversionen. Stehend, liegend, rumgedreht von der Rückseite usw....
* LPC21xx / LPC22xx / LPC23xx |
* EINE AVR ATmega-Bibliothek, wo ALLE Controller drin sind. |||||||
* AVR XMegas |
* AT90CAN128 / allgemein mehr AVRs (MEGA & TINY) ||||||
*Wegen der AVRs und ATMEGAs: Bitte hier http://www.kicadlib.org/Fichiers/Kerusey_Karyu_Atmel_Library.html mal schauen, und den Wunsch auf den Typ konkretisieren! Der Atmelzoo ist so verwirrend vielfältig.....
** Leider ist die dazugehörige Bibliothek defekt.
** Ist aktualisiert worden und in die aktuelle KiCad Symbol Library eingeflossen: [https://github.com/KiCad/kicad-library/blob/master/library/atmel.lib]
***Weitere Aktualisierungen und Erweiterungen: [https://github.com/KiCad/kicad-library/blob/master/library/atmel.dcm]
* Schaltregler (u.A. LM257x, LM267x, MC33063, L5973D) |||| Der MC33063 hat gleiches Pinning und Gehäuse wie MC34063! Darum kann der in http://www.mikrocontroller.net/wikifiles/8/84/Symbols_ICs-Diskrete_RevD9.lib verwendet werden.
* Spulen (z. B. diverse Wuerth) ||
* Drosseln (B82790 für CAN, Würth 744207) |
* Transformatoren (allgemein) |
* Ferrite (7427930 - 32, 742792651, 74279263) |
** ??? Was genau ist nun Footprint und Referenzmaeßig der Unterschied zwischen Drosseln, Spulen und Ferriten, wenn ich jetzt mal davon ausgehe, das die Teile weder Anzapfung noch mehr als eine Wicklung haben (dann wären es Trafos oder Uebertrager), und die elektrischen Werte in ein Feld eingetragen werden?? Schau mal unten in http://www.mikrocontroller.net/wikifiles/d/da/KiCAD_Module_Footprints_3D_16Sep2013.zip. Kleinere SMD-Entstörferrit Module lassen sich uebrigens aus Footprints für SMD-Widerstaenden zaubern, in dem man sie umbenahmt und mit der Referenz "L" versieht. ;-)
* STM32 Mikrocontroller Bibliothek (sofern möglich alle) |||
* Arduinos |
** Arduino Due ||

=== Entwürfe ===

Neue Bibliotheken oder Änderungen sollen zunächst in diesem Abschnitt
vorgestellt werden.

==== Symbolbibliotheken ====

* [http://www.mikrocontroller.net/topic/96460#832961 ATmega3250/TQFP100] von Fred S. (Gast)

* [http://www.mikrocontroller.net/topic/96460#844741 ATMega3290 im 100Pin-Gehäuse] von Fred S. (Gast)

* [http://www.mikrocontroller.net/topic/132811#1205130 RFM12-Funkmodul] von Dominik C.

* [http://www.mikrocontroller.net/topic/133310#1210137 CAN Controller MCP2515 und Transceiver MCP2551] von Dominik C.

* [[Media:SymbolsSimilarEN60617+oldDIN617-RevB-en.lib]] VERALTET! Nur aus Kompatibilitätsgründen behalten. Ersetzt für Neuentwicklungen durch Revision E1. Schaltplan Symbolbibliothek fuer KiCAD mit Symbolen, die denen aus der EN60617 oder der ALTEN DIN 617 ÄHNLICH sind. Von Bernd Wiebus

* [[Media:SymbolsSimilarEN60617+oldDIN617-RevC-en.lib]] VERALTET! Nur aus Kompatibilitätsgründen behalten. Ersetzt für Neuentwicklungen durch Revision E1! Schaltplan Symbolbibliothek für KiCAD mit Symbolen, die denen aus der EN60617 oder der ALTEN DIN 617 ÄHNLICH sind. Aenderung gegenueber Rev.B: Kleinere Symbole hinzugefügt. Mit Vorsicht geniessen! Von Bernd Wiebus.

* [[Media:SymbolsSimilarEN60617+oldDIN617-RevD3-en.lib]] VERALTET! Nur aus Kompatibilitätsgründen behalten. Ersetzt für Neuentwicklungen durch Revision E1! Schaltplan Symbolbibliothek für KiCAD mit Symbolen, die denen aus der EN60617 oder der ALTEN DIN 617 ÄHNLICH sind. Aenderung gegenueber Rev.C: Kleinere Fehler beseitigt. CLD Symbol hinzugefuegt. Kuehlkoerper Symbol und Dummy-Symbol fuer Boardoutlines hinzugefuegt. Thyristor und Triac Symbol zugefuegt. Copyright Symbole GNU-GPL und CC zugefuegt. Mit Vorsicht geniessen! Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:SymbolsSimilarEN60617+oldDIN617-RevE8.lib]] AKTUELLE Version! Ersetzt die Rev. B, C und die Rev. D sowie Vorgängerversionen E1-E7! Schaltplan Symbolbibliothek für KiCAD mit Symbolen, die denen aus der EN60617 oder der ALTEN DIN 617 ÄHNLICH sind. Aenderung gegenueber Rev.D: Kleinere Fehler beseitigt. Ankerpunkte in die Nähe der Symetrieachsen verlegt. Verbinder DIN41612 / EN60603-2 "Eurokartenstecker" hinzugefügt. Große "BIG" Symbole entfernt und in der Datei BIG-SymbolsSimilarEN60617+oldDIN617-RevE.lib ausgelagert. Mit Vorsicht geniessen! Von Rene Belau und Bernd Wiebus. CC-Zero/Public Domain! Defektes Symbol "RESISTOR_RevE_Date15jun2010" repariert am 02. Maerz 2011. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:BIG-SymbolsSimilarEN60617+oldDIN617-RevE.lib]] Einige EN60617 oder der DIN 617 ÄHNLICHE Symbole in besonders GROSSER Ausführung. Vermutlich werden Sie diese GROSSEN Symbole eher NICHT benutzen wollen. Mit Vorsicht geniessen! Von Rene Belau und Bernd Wiebus. Unter GNU GPL. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[http://www.mikrocontroller.net/attachment/74203/obi.lib]] KiCAD Symbol für einen ATMEGA644. Von obi

* [[Media:Symbols_ICs-Diskrete_RevD10.lib]] KiCAD Symbole für einige diskrete ICs. Enthält L200 (Pentawatt Gehäuse), LM2587 (Pentawatt Gehäuse), Längstregler LM317, LM78xx, LM79xx, Timer NE555, NF-Verstärker LM1875 und TDA2003 (Pentawatt Gehäuse), Schaltregler UC38xx (DIP8/SO8 und DIP14/SO14), LM2587, MC34036, LM78S40 und MCP1640, Treiber MIC4422 (DIP8/SO8 und Pentawatt Gehäuse). Allegro Halleffekt Stromwandler Typ ACS754/ACS755/ACS756 und LEM Halleffekt Stromwandler der Serie "HX". Programierbarer Oszillator Si570/Si571 sowie Quarzoszillator Typ KXO-200. Dazu Transistor Arrays BC847S und BC857S (in einfacher und in aufgelöster Darstellung) und Supressordioden Array SR05. Schieberegister 74HC4094 . Spannungs-/Laderegler uA723/LM723 in 14 und 20 poligem Gehäuse. HF/ZF Verstärker/Mischer/Demodulator TCA440 alias exDDR A244D, FM Frontend TA7358. Spannungsmonitor ICL7665. Autor Bernd Wiebus. CC-Zero/Public Domain! Mit Vorsicht geniessen! Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Symbols_ICs-Opto_RevB_16Sep2013.lib]] KiCAD Symbole für Optokoppler CNY17, IL300. IL388, TLP250, SFH617A-1, SFH617A-2, SFH617A-3, SFH617A-4, KPC357, LTV35x, und PC357. LWL Empfänger Toshiba TORX170 TORX173 TORX193 und TORX194 (Toslink). LWL Sender Toshiba TOTX170 TOTX173 TOTX193 und TOTX194 (Toslink). LWL Empfänger Agilent HFBR-252x und Sender Agilent HFBR-152x Serie (Versatile Link). 7 Segment Anzeigen HDSM531, HDSM533, LTS6760, LTS6780, SBC18-11EGWA. Autor Rene Belau und Bernd Wiebus. CC-Zero / Public domain. Mit VORSICHT geniessen! Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Transformer-Diskrete_RevA.lib]] KiCAD Symbole für einige diskrete Transformatoren. Coilcraft Q4434-B = Rhombus T1311 und Myrra-74040 ETD29. Autor: Bernd Wiebus. Mit Vorsicht geniessen! Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Symbols_DCDC-ACDC-Converter_RevC_29Aug2014.lib]] KiCAD Symbole für einige DCDC/ACDC-Converter. Enthält CINCON EC5BC12, CINCON EC6C11, TRACO TED-1212, TRACO TED-XXXX Dual Output, TRACO TED-XXXX Single Output, TRACO TEN10-1212, TRACO TEN10-XXXX, TRACO TME-XXXX, TRACO TMH-XXXX Single Output, TRACO TMH-XXXX Dual Output, sowie TRACO ACDC-Converter der TMLM Serie. BOTHHAND CF-Serie und DELTA DPS05U09D. Neu seit 29 August 2014: Floeth DCDC-Converter SD14-XXXX und SD18-XXXX. Autor: Bernd Wiebus. GNU-GPL. Mit Vorsicht geniessen! Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Symbols_Socket-DIN41612_RevA.lib]] KiCAD Symbole für DIN41612 Stecker und Buchsen (Die bekannten Eurokartenstecker). Autor: Bernd Wiebus. GNU-GPL. Mit Vorsicht geniessen! Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Symbols_EN60617_13Mar2013.lib]] KiCAD Symbole für die EN60617. Strikter als die Symbole aus SymbolsSimilarEN60617+oldDIN617-Rev~~.lib. Autor: Bernd Wiebus. CC-Zero/Public Domain! Mit Vorsicht geniessen! Hierzu gehört der Katalog: [[Media:Symbols_EN60617_13Mar2013.pdf]] Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Symbols_EN60617-10_HF-Radio_DRAFT_12Sep2013.lib]] HF-Blockschaltbild Symbole für KiCad. EXPERIMENTELL! Autor: Bernd Wiebus. Mit Vorsicht geniessen! Lizenz: CC-Zero / Public domain. Hierzu gehört der Katalog: [[Media:EN60617-10_HF-Radio_SymbolCatalog_DRAFT.pdf]] Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Symbols_Microcontroller_Philips-NXP_RevA_06Oct2013.lib]] Symbole der NXP Microcontroller LPC2104, LPC2105 und LPC2106 fuer KiCad. Autor: Bernd Wiebus. Mit Vorsicht geniessen! Lizenz: CC-Zero / Public domain. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

==== Modulbibliotheken ====

* [[Media:KiCAD_Module_Footprints_3D_29Aug2014.zip]] Eine Sammlung von KiCAD Modulen bzw. Footprints diskreter Bauteile. Neben den obligatorischen Rs, Cs und Ls sind Schrack und Omron Kartenrelais (die Footprints passen auch fuer andere Hersteller), diverse Dioden, Klemmen WAGO 236 (RM 5mm) Serie und WAGO 734 Serie, Sicherungshalter (Schurter und Bulgin) für 5x20 und 6x30, SMD Sicherungen 1206 und Sicherungen/Sicherungshalter TE5/TR5,Flachsicherungen Standard und Mini, Kuehlkoerper und Eurokartenoutlines enthalten. Zusaetzlich TO92, TO220, TO220-5 (Pentawatt) und TO247 Gehaeuse. Ebenso die vermissten PISN und PISR SMD Drosseln. Einige Throughhole C&D Bobin Drosseln, Bourns 3296, Spectrol Type 43 / Econtrim und Piher PT15 Trimmer . Potentiometer Alps RK16 und Spectrol Type 148/149. Transformatoren Coilcraft Q4434-B / Rhombus T1311 sowie ETD29 von Epcos und Myrra sind auch dabei. Eurokartenstecker/-buchsen DIN 41612 Typ B1, B2, C1, C2 und C3. Ebenfalls enthalten: GNU-GPL und Creative Commons Symbole. Dazu Messpunkte. BNC-Buchse, Quarzoszillator, SMD Widerstände und Kondensatoren. (0805, 1206, 2512) sowie experimentelle Universalfootprints SMD/Throughole. SMD-Dioden: MELF, Mini-MELF, SMA, SMB und SMC. Halleffekt Stromwandler mit Allegro CB-PFF, CB-PSF und CB-FSS Gehäusen.Dazu Stecker Molex Serie KK, Würth SMD Drosseln und Doppeldrosseln. Neosid Filter und Drosseln. TRACO ACDC-Converter der TMLM Seie und SOT23, SOT143, SOT143R, TSOT-6 / MK06A sowie SC70-6 SMD Footprints für Dioden, Transistoren bzw. Dioden und Transistor Arrays und kleinere ICs. Mini Universal Mate-N-Lock Steckersockel (Tyco/AMP). 2-6 Pin, vertikale und horizontale Typen. Verbesserte Fiducials und Logos. Dazu SMD-Tantalkondensatoren und ETAL NF-Transformatoren. TO50-3 und TO50-4 Gehäuse. 7 Segment Anzeigen. LQFP48/TQFP48 Gehäuse. Hallsonden Stromwandler mit Allegro CB-PFF, CB-PSF und CB-FSS Gehäusen. Halleffekt Stromwandler der Serie "HX" von LEM. Neu in der Version vom 29. August 2014: Floeth DCDC-Converter SD14 und SD18. Fast alles ohne 3D Modelle, aber manchmal mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und CC-Zero/Public Domain! Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:KiCAD-Module_Buzzer_Beeper_RevA_25Oct2010.zip]] Einige Footprints von Summern /Buzzern / Beepern für KiCAD. Enthaelt Kingstate KCG0601, Pro Signal ABI-009-RC, Pro Signal ABI-010-RC, Pro Signal ABT-410-RC, Star Micronics HMB-06/HMB-12 und Projects Unlimited AI-4228-TWT-R. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und CC-Zero/Public Domain! Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:KiCAD-Module_CommonModeChoke_Wuerth_Type-WE-CMB_RevA_25Oct2010.zip]] Footprints der Gleichtaktdrosseln der Serie Würth WE CMB (through hole) für KiCAD. Enthält die Verschieden Bauformen XS, S, M, L, XL und XXL. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und CC-Zero/Public Domain! Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:DCDC-ACDC-Converter_RevC_20Jul2012.zip]] Footprints von DCDC/ACDC-Convertern für KiCAD. Enthält CINCON EC5BC12, CINCON EC6C11, TRACO TED-1212, TRACO TED-XXXX Dual Output, TRACO TED-XXXX Single Output, TRACO TEN10-1212, TRACO TEN10-XXXX, TRACO TME-XXXX, TRACO TMH-XXXX Single Output, TRACO TMH-XXXX Dual Output, BOTHHAND CF-Serie und DELTA DPS05U09D. Neu seit 20 Juli: TRACO ACDC-Converter der TMLM Serie. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und CC-Zero/Public Domain! Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Opto-Devices_RevC_03Oct2012.zip]] Footprints von Optoelectronischen Bauteilen für KiCAD. Enthält 6 Polige DIL Footprints für CNY17, auch in "wide", SMD Optokoppler Footprints (1 Kanalig) und Footprints für Toshiba (Toslink) und Agilent (Versatile Link) LWL Ssender und Empfänger. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und unter GNU-GPL. Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Pentawatt_RevB_24Oct2012.zip]] Footprints von Pentawatt Gehäusen für KiCAD. Enthält verschiedene Ausführungen der TO220-5 Gehäuse in gerade und verkröpft, sowie stehend und liegend. Mit 3D-Modellen und mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und unter GNU-GPL. Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:Transistor_TO-220_RevB_03Sep2012.zip]] Footprints von TO220-3 Gehäusen für KiCAD. Enthält verschiedene Ausführungen der TO220 Transistor Gehäuse in stehend und liegend. Mit 3D-Modellen und mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! CC-Zero/Public domain! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:Transistor_TO-247_RevC.zip]] Footprints von TO247 Gehäusen für KiCAD. Enthält verschiedene Ausführungen der Transistor Gehäuse in stehend und liegend. Mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! CC-Zero/Public domain! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[http://www.mikrocontroller.net/topic/176405#new]] KiCAD Modul / Footprint für ein TSSOP38 Gehäuse. Autor Raphael Reu.

* [[http://www.mikrocontroller.net/topic/190088#1856759]] Texas Instruments TPIC8101 Klopfsensor Interface (für Verbrennungsmotoren). Autor Peter Diener.

* [[Media:IR-directFET_Packages_RevB.zip]] Footprints von directFET SMD-Transistor Gehäusen von International Rectifier für KiCAD. Enthält die SH, SJ, SQ, ST, S1, MN, MP, MT, MX, MZ und die L8-Outline. Nähere Informationen in den Datenblättern betroffener Transistoren und in der International Rectifier Applikationsnotiz AN-1035. "directFET" ist übrigens eine Handelsmarke von International Rectifier und die Gehäuse sind proprietär. Also vorsichtig sein und an "second source" denken. Mit 3D Modellen und mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und unter CC-Zero / Public domain. Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Neosid-Devices_Coils_Filters_25Apr2012.zip]] Footprints von NEOSID Bauteilen. Spulen, Luftspulen, Filter ec. für KiCAD. Through hole und SMD. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und unter GNU-GPL. Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:SOT23_SOT143_SOT143R_TSOT6_MK06A_SC70-6_Housing_14Mar2014.zip]] Footprints von SOT23, SOT143, SOT143R, TSOT-6 /MK06A und SC70-6 SMD Gehäusen, wie sie oft für Dioden und Transistoren, aber auch Dioden und Transistor Arrays verwendet werden. Auch ICs findet man in der Bauform. Es sind Standard Footprints und spezielle für Handlötung vorhanden. KiCad Legacy Format und neues .pretty Format. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und unter GNU-GPL. Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:MiniUniversalMate-N-LokSockets_13Aug2012.zip]] Footprints von Mini Universal Mate-N-Lok Steckersockeln (Tyco/AMP). 2-6 Pin, verticale und horizontale Typen. Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Mit Vorsicht geniessen! Ohne Garantie und unter GNU-GPL. Von Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:NF-Transformer_ETAL_RevA_28Aug2012.zip]] Footprints und 3D-Mesh Modelle von NF-Transformatoren der Firma ETAL (http://www.etalgroup.com). SMD und THT Typen. Mit PDF-Ausdruck zur leichteren Identifikation. In der Bibliothek ist auch der bekannte Übertrager ETAL P1200, der von Box73 (http://www.box73.de) vertrieben wird. Mit Vorsicht geniessen! Ohne Garantie und unter GNU-GPL. Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:TantalCapacitors_SMD_RevA_28Aug2012.zip]] Footprints von Tantal Kondensatoren SMD Größe A bis E (EIA-3216, EIA-3528, EIA-6032, EIA-7343 und EIA-7360). Alles ohne 3D Modelle, aber mit PDF-Ausdruck zur leichten Identifikation. Ohne Garantie und unter GNU-GPL. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:SOT89-3_SOT89-5_Housing_RevA_02Sep2012.zip]] Footprints und 3D-Mesh Modelle von SOT89-3 und SOT89-5 SMD Gehäusen. Mit PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter GNU-GPL. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:SOT126_SOT32_Housings_RevA_22Oct2012.zip]] Footprints und 3D-Mesh Modelle von SOT126 / SOT32 Gehäusen. Mit PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter GNU-GPL. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:Allegro_HallSensors_24Oct2012.zip]] Footprints und 3D Modelle von Allegro Hall-Effect Stromsensoren mit PFF, PSF oder PSS Gehäuse (ACS754, ACS755, ACS756). Mit PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter GNU-GPL. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

* [[Media:VML0806_Housing_Rohm_27Oct2012.zip]] Footprints und 3D Modell eines Transistors im 0806 Format (VML0806 / Rohm). Mit PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter GNU-GPL. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:TO-50_Housings_RevA_21Apr2013.zip]] Footprints/Module von TO50-3 und TO50-4 Transistor Gehäusen.Mit PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:OldSowjetAera_Transistor_RevA.zip]] Footprints/Module von Kleinleistungstransistoren aus der Sowjetära.Mit 3D-Modell und PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:SIP9_Housing_14Jun2013.zip]] Footprints/Module von SIP9 Gehäusen (z.B. TA7358).Mit 3D-Modell und PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:7Segment_16Sep2013.zip]] Footprints/Module von 7-Segment Anzeigen HDSM531 (SMD), HDSM533 (SMD), LTS6760, LTS6780 undSBC18-11EGWA. Dazu PDF-Ausdruck zur leichteren Identifikation. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:BNC-Sockets_RevA.zip]] Footprints/Module von TYCO BNC-Buchsen für KiCad. Mit 3D Modellen und PDF Preview. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:LQFP_TQFP_RevA_06Oct2013.zip]] Footprints/Module von LQDP48/TQFP48 Gehäuseb für KiCad. Ohne 3D Modelle, aber mit PDF Preview. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

*[[Media:LEM_HallEffectTransducers_RevA_13Oct2012.zip]] Module/Footprints von Halleffekt Stromwandlern der Serien "HX" und "HTFS" von LEM. Mit 3D-Modellen und PDF Preview. Ohne Garantie und unter CC-Zero / Public Domain. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

==== 3D-Modelle ====

* [[Media:MeshModells_VRML-Wings3D_13Oct2013.zip]] 3D-Modelle diverser elektronischer Bauteile im wrl 2.0 und wings Format. Enthalten: DD-PAK (TO263AB), D-PAK (TO252AA), SMD Dioden MELF, MiniMELF, SMA, SMB und SMC, Transformatoren ETAL P1165, P1200, P2781, P3000, P3181, PP3188 und P3191, SO126 / SOT32 in horizontal und vertikal, SOT223-3, TO263-3, SOT89-3, SOT89-5, TO220 horizontal und vertikal und reverse. TO220-5 horizontal, vertical, inline und verkröpft, VML0806. SIP9. 7 Segment SMD Anzeige HDSM531/HDSM533 in Grün, gelb, rot und orange. directFET SMD-Transistor Gehäusen von International Rectifier für KiCAD. Enthält die SH, SJ, SQ, ST, S1, MN, MP, MT, MX, MZ und die L8-Outlines. Flachsicherungen Standard und Mini. Halleffekt Stromwandler LEM "HX" Serie und Allegro ACS754/ACS755/ACS756 mit CB-PFF, CB-PSF und CB-FSS Gehäusen. Ohne Garantie und unter CC-Zero / Public Domain Lizenz. Mit Vorsicht geniessen! Autor: Bernd Wiebus. Verbesserungsvorschläge willkommen an bernd.wiebus@gmx.de

==== Building-Blocks ====
*[[Media:BuildingBlocks_16Jun2013.zip]] enthält eine Sammlung von gängigen Schaltungen mit den Längstreglern LM317 /LM78xx /LM79xx und dem Timer 555, die nach dem in diesem [[Media:HierarchischeSchaltplaeneAlsBausteineInKicad_RevC_23Dec2013.pdf]] Dokument beschriebenen Vorgehen als Building Blocks in KiCAD verwendet werden können. Ein Katalog dazu befindet sich hier: [[Media:KatalogUeberKiCadBuildingBlocks_21Apr2013.pdf]]. Autor: Bernd Wiebus, Lizenz: Creative Commons. Experimentell! Ohne Garantie! Mit Vorsicht geniessen!

Wenn mindestens ein weiterer KiCAD User die Bibliothek geprüft hat, kann sie in den folgenden Unterabschnitt verschoben werden.

=== Geprüfte ===

Hier sollen geprüfte Bibliotheken gesammelt werden. Bitte angeben, wer die Prüfung gemacht hat.

* [http://www.mikrocontroller.net/topic/132288#new STM32F103xx (LQFP64) Schaltplansymbol] erstellt/geprüft: Dominik C.; Marko S.

*Bei der STMF103xx fehlt glaub ich der Portpin PD2 :) Grüße :)

=== Sonstige Bibliotheken im Netz ===
* https://github.com/KiCad/kicad-library Neues offizielles Repository bei Github.
* https://github.com/KiCad Allgemeines Repository bei Github.
**https://github.com/KiCad/kicad-library/blob/master/KiCad_Library_Convention.txt Conventionen für die Github Bibliotheken. Bitte beachten, das noch nicht alle Bibliotheken umgestellt sind.
**https://github.com/KiCad/kicad-library/blob/master/CONTRIBUTING.txt Wie man selber Bibliotheken in das KiCad Repository einfügen kann.
* http://www.kicadlib.org/
* http://per.launay.free.fr/kicad/kicad_php/composant.php
* http://www.reniemarquet.cjb.net/kicad/libs/o_analog.zip (NE555 u.a.)
* http://github.com/Inte/kicadlib
* http://www.df0fkw.datenoase.de/index.php?option=com_content&view=article&id=107:kicad-libraries&catid=36:bastelprojekte&Itemid=67
* http://bytelabs.ch/kicadlib.html
* http://library.oshec.org/ Von EAGLE konvertiert, also Vorsicht bei der Verwendung!
* http://smisioto.no-ip.org/elettronica/kicad/kicad-en.htm

== Tools ==

Da die in KiCad verwendeten Dateien klarschriftlesbar sind, lassen sie sich sehr leicht mit externen Programmen und Skripten bearbeiten, um spezielle Funktionalitäten zu erzeugen. Eine kleine Auswahl an Programmen/Skripten ist hier zusammengestellt:

* [http://kicad.rohrbacher.net/quicklib.php Quick KICAD Library Component Builder]
* Gerber-Tools sind für KiCAD weniger nötig, da KiCAD mit GerbView seinen eigenen Gerberviewer mitbringt. Dieser ist mächtig genug, die eingelesenen Gerberfiles als Platine in PCBnew zu exportieren, wo sie manipuliert werden können. Dieses geht aber nur mit Gerber-RS274X Daten. Ebensowenig können Gerberfiles zu Nutzen zusammengefügt werden. Hierzu bietet sich "Gerbmerge" http://ruggedcircuits.com/gerbmerge (http://claymore.engineer.gvsu.edu/~steriana/Python/gerbmerge/ Veraltet) an. Wer lediglich aus Sicherheitsgründen die von KiCAD erzeugten Gerberdaten mit einem fremden Gerber-Vierer inspizieren möchte, findet hier Hinweise:http://www.mikrocontroller.net/articles/Gerber-Tools
* [http://www.mikrocontroller.net/topic/204063#2011138 KiCAD (Multi-)Symbol Tool] von Joghurt3000 zur Erstellung von Symbolen aus einer Textvorlage
* [http://cyclerecorder.org/footprintbuilder Footprintbuilder] Java-Programm zu Erstellung von Footprints.
*Wer seine Platine "panelisieren" (d.h. mehrmals nebeneinander anordnen um in einem "Nutzen" gleich mehrere Platinen fertigen zu können) möchte, kann das mit dem Python 2 Skript "panelize.py" tun. Das Programm arbeitet direkt auf den kicad .brd Files, so das das Mehrfachnutzen Board unter PCBnew nachbearbeitet werden kann, für z.B. einen DRC. "panelize.py" kann hier bezogen werden: http://blog.borg.ch/?p=12
* "Raef" hat ein Python Script erstellt, das Bauteile automatisch ähnlich der Anordnung im Schaltplan plaziert. Siehe: http://www.mikrocontroller.net/topic/293903#3245990
*Wer die Reihenfolge der Subschaltpläne ändern will (Wegen Übersichtlichkeit/Bestimmt auch die Reihenfolge beim Ausdrucken), kann dieses Python 3 Skript verwenden (Liesmich/Readme beachten): http://www.mikrocontroller.net/wikifiles/9/90/PyKicadSchematic-ID_Interchanger_RevC.zip Autor: Bernd Wiebus, GNU-GPL. Dieses Skript ist unabhängig von der PCBnew internen Python 2 Schnittstelle.
* Um ältere Schaltpläne von vor Jan./Feb. 2014 (BZR4646) mit "upper case" Symbolnamen zu konvertieren, kann dieses Python 3 Skript verwendet werden: [[Media:PyKiCad-CaseSensitiveLibCure_RevD_13Apr2015.zip]]. Autor: Bernd Wiebus, GNU-GPL. Dieses Skript ist unabhängig von der PCBnew internen Python 2 Schnittstelle.
* Wem das Tricksen mit Dateimanager oder Schematic oder Board als Bibliotheksmanager nicht gefällt, findet vieleicht im "KiCad Libarian" ein passendes Tool: http://www.compuphase.com/electronics/kicadlibrarian_en.htm
* Diverse Skripte, um KiCad Symbole, Footprints oder sonstigen Bibliothekskram zu bearbeiten. [https://github.com/KiCad/kicad-library-utils]
* Cirillo Bernardo hat einige Programme geschrieben, um VRML 3D Gitter Modelle für Bauteile parametrisch zu erzeugen. Sie finden sich hier: https://github.com/cbernardo/kicad3Dmodels
* Peter Hofbauer hat einige Windows Programme geschrieben, die zur KiCad Unterstützung dienen: http://www.hcp-hofbauer.de/software.htm Bei den Programmen handelt es sich um "Aufräumprogramme für Bibliotheken, Stücklistenerzeugung, Extraktionsprogramm um eine Verdrahtungsliste aus einer Netzliste zu erzeugen, Ein Programm um Boherdurchmesser zu vereinheitlichen und ein Programm, um zusammen mit "Linegrinder" G-Code aus KiCad Boarddateien zu erzeugen.
* [http://escalalibre.com/edwt/kicad_sizeConverter.php KiCad Bitmap2Component Skalierer] Erlaubt es, Logos zu skalieren.
* [http://escalalibre.com/edwt/kicad_modTextChanger.php KiCad Module Text Changer]

=== Konverter ===

Konverter wandeln KiCad-Daten in die Daten anderer Layoutprogramme bzw. die Daten anderer Layoutprogramme in KiCad-Daten um.
Nativ kann KiCad gEDA Footprints bzw. neuere Eagle Footprints direkt als Bibliothek einbinden. Das ganze ist aber als noch sehr experimentell zu betrachten.

Desweiteren gibt es einige Programme oder Skripte von dritter Seite, die Daten anderer Layoutprogramme in KiCad Daten umwandeln. Auch diese sind als experimentell einzustufen.

Hier eine Auswahl:
* https://github.com/thesourcerer8/altium2kicad Wandelt Altium Schaltpläne und Layouts in KiCad Daten um.
* https://github.com/DanChianucci/Eagle2Kicad Wandelt Eagle 6.0 Layouts in KiCad Layouts.
* https://github.com/lachlanA/eagle-to-kicad Wandelt Eagle 6.0 Layouts in KiCad Layouts.
* http://www.cadsoft.de/downloads/file/eagle2kicad-0.9c.ulp Direkt von der Cadsoft Seite, ein ULP das Eagle Daten in KiCad Daten wandelt.
* http://www.cadsoft.de/downloads/file/eagle2kicad_sch.ulp Ebenfalls direkt von der Cadsoft Seite, ein ULP, das Eagle Schaltpläne in KiCad Schaltpläne wandelt.
* http://sourceforge.net/projects/pcad2kicad/ Wandelt P-CAD Schaltpläne, Layouts und Bibliotheken in KiCad Daten um.

Erfahrungsberichte willkommen!

== Beispielprojekte ==

* http://www.mikrocontroller.net/topic/33653#963083 JTag-wiggler
* http://www.mikrocontroller.net/topic/190088#1856757 Klopfsensor von Peter Diener.
* http://www.mikrocontroller.net/topic/188897 Open-Hardware / Open-Source USB-basierter SPI BIOS-Chip Programmer von Uwe Hermann
* http://www.mikrocontroller.net/articles/Modellbahn_Servodecoder_f%C3%BCr_Weichen_mit_R%C3%BCckmeldung Modellbahn Servodecoder für Weichen mit Rückmeldung
* http://www.mikrocontroller.net/articles/RS485_IO_Board_-_ModellBahnLichtSteuerung RS485 IO Board - ModellBahnLichtSteuerung
* [[Media:UndervoltageProtection_RevD_14Aug2012.zip]] Beispielprojekt eines Tiefentladeschutzes für einen Blei-Gel Akku, der von den Platinenabmessungen her auf einen typischen 12V/7,2Ah Akku passt. Ausserdem bietet er abgesicherten Zugang zu den Akkuklemmen, was auch in vielen Fällen beachtenswert ist. Leider ist das Projekt noch etwas unaufgeräumt, es fehlen noch Bauteilwerte, und in der Form wurde noch keine fertige Platine daraus hergestellt, aufgebaut und getestet. Autor: Bernd Wiebus, GNU-GPL.
* http://www.mikrocontroller.net/topic/338835#3724591 Universeller Adapter PDI, JTAG, ISP mit KICAD
* http://n8vem-sbc.pbworks.com/w/page/4200908/FrontPage Eine Seite mit Selbstbaucomputern, teilweise "Retro" mit S100 Bus.
* [[Media:DC-50Ohm_Terminierung_RevE_25Mar2015.zip]] 50 Ohm DC entkoppelte Terminierung fuer Oszilloskope. [[Bild:DC-50Ohm_Terminierung_Downside.png|thumb|150px|Unterseite des DC-Messadapters mit kapazitiv entkoppelter 50 Ohm Terminierung]] [[Bild:DC-50Ohm_Terminierung_Upside.png|thumb|150px|Oberseite des DC-Messadapters mit kapazitiv entkoppelter 50 Ohm Terminierung]] Dieses Beispiel enthält Board-Dateien Version 5. Möchte man diese mit einem älteren KiCad, welches nur Version 4 kennt, öffnen, so müssen die Dateien angepasst werden. Eine Anleitung findet sich hier: [[Media:KiCad-PCBnewBoardDateienMigrierenVonVersion4Auf5.pdf]]
* https://www.mikrocontroller.net/attachment/261855/QRP-SWR-Bridge_ModC_RevA-pretty_11Jul2015.zip Resistive SWR-Messbrücke für QRP Kleinleistung auf Kurzwelle. Einer der Vorteile ist hohe Empfindlichkeit und dass sie auch bei Fehlanpassung dem Senderausgang einen bedämpften, halbwegs passenden Abschluss bietet. Anwendungsbeispiel Moqsquita ( http://www.qrpproject.de/Media/pdf/Mosquita40.pdf ) für 40m und weitere Infos, auch zu Bauteilen, finden sich hier im Thread: https://www.mikrocontroller.net/topic/371365#4194810 Dieses Beispiel enthält Board-Dateien Version 5. Möchte man diese mit einem älteren KiCad, welches nur Version 4 kennt, öffnen, so müssen die Dateien angepasst werden. Eine Anleitung findet sich hier: [[Media:KiCad-PCBnewBoardDateienMigrierenVonVersion4Auf5.pdf]]

== Diskussionen (teilweise seeeehr alt) ==

* http://www.mikrocontroller.net/topic/120373#1089075
* http://www.mikrocontroller.net/topic/98034#848559
* http://www.mikrocontroller.net/topic/95864#828660
* http://www.mikrocontroller.net/topic/77738#647041
* http://www.mikrocontroller.net/topic/103806#907523
* http://www.mikrocontroller.net/topic/41999#316195

== Weblinks ==

* [http://iut-tice.ujf-grenoble.fr/kicad/index.html KiCAD] Homepage 1 und Download
* [http://www.lis.inpg.fr/realise_au_lis/kicad/ KiCAD] Homepage 2 und Download
* [http://www.kicad-pcb.org/display/KICAD/KiCad+EDA+Software+Suite KiCAD] Neue Homepage
* [http://www.kicad-pcb.org/display/KICAD/KiCad+Scripting+Reference+Manual] Speziell Informationen zum Python-Scripting.
* [http://kicad.sourceforge.net/wiki/index.php/DE:Main_Page KiCAD Wiki]
* Tutorials:
** [http://kicad.sourceforge.net/wiki/index.php/DE:Mini_tutorial Mini-Tutorial]
** [http://timogruss.de/kicad-loesung-fuer-die-leiterplatten-entwicklung/ KiCad Tutorial auf timogruss.de] (deutsch)
** http://www.curiousinventor.com/guides/kicad
** http://xtronics.com/reference/kicad.html
** http://bastler-archiv.de/elektronik/platinenherstellung-platinenlayout-mit-kicad-teil-1/ (deutsch, Teil 1)
** http://bastler-archiv.de/elektronik/platinenherstellung-platinenlayout-mit-kicad-teil-2/ (deutsch, Teil 2)
** http://www.kramann.info/73_COACH3/06_Layouting/Layouting_art_Guido_Kramann_12122010.pdf
** https://contextualelectronics.com/course/kicad-tutorial/ (Video Tutorials auf Englisch)

* Usergroups:
** [https://groups.yahoo.com/neo/groups/kicad-users/info Yahoo-KiCAD-User-Group (Englischsprachig)]
** [https://forum.kicad.info/ Endlischsprachiges KiCad Forum]
** [http://1.cad-kicad-user.cadtalk.us/ Englischsprachige Diskussionen über KiCad im "Cadtalk"-Forum] Leider nicht mehr existent.
* Tools
** [http://www.freerouting.net/ Freerouting] Autorouter
** [http://www.mikrocontroller.net/articles/KiCAD#Tools Liste mit externen Programmen und Skripten im Zusammenhang mit KiCad]
* Verschiedenes im Zusammenhang mit KiCad
** [https://github.com/KiCad/kicad-library/wiki/Kicad-Library-Convention Kicad Library Convention / Regeln für offizielle KiCad Bibliotheken (Englisch)]
** [http://www.compuphase.com/electronics/LibraryFileFormats.pdf Aufbau der unterschiedlichen KiCad Bibliotheks Files (englisch)]
** [http://www.ohwr.org/projects/cern-kicad/wiki/WorkPackages CERN KiCad development roadmap / Was ist in KiCad Entwicklung geplant? (englisch)]
** [http://home.web.cern.ch/about/updates/2015/02/kicad-software-gets-cern-treatment Warum das CERN KiCad unterstützt (englisch)]
** [https://www.youtube.com/watch?v=chejn7dqpfQ Video mit der Leiterbahnlängenanpassen Funktion bzw. der "Differential pair" Funktion in KiCad.]
** [http://www.youtube.com/watch?v=irqlrVUbjuQ Video mit dem interaktiven Router]
* Plattformen
** Mac: http://brokentoaster.com/kicad/
**Ubuntu: [http://www.mikrocontroller.net/topic/257321#2658268 KiCAD selber compilieren]
** http://wiki.xtronics.com/index.php/Kicad Transtronics site (englisch)
* HowTo von Tom Boyd (englisch)
** http://kicadhowto.wikidot.com/
** http://kicadhowto.org/
* Bugreports! Wer einen Bug gefunden hat, bitte [https://bugs.launchpad.net/kicad hier] angeben! Kicad wird laufend verbessert. Hier kann auch schon nach vorhandenen Reports gesucht werden, wenn einem etwas komisch vorkommt.

[[Category:Schaltplaneditoren]]

Diskussion:Wer hat was

2015-08-16T08:14:10Z

Kichi: Die Seite wurde neu angelegt: „Evtl. wäre es sinnvoll die Liste nach PLZ-Bereichen aufzubauen.“

Evtl. wäre es sinnvoll die Liste nach PLZ-Bereichen aufzubauen.

STM32 Eclipse JLink Linux/Windows

2015-06-28T12:25:19Z

Kichi: /* Installation */

== Einführung ==
Da viele Tutorials zur Verwendung von Eclipse mit [[STM32]] auf relativ alten Tools aufsetzen, hier eine Anleitung mit aktuellem (2015) Stand. Hier wird die Programmierung von STM32 (ähnlich auch auf andere Cortex-M anwendbar) mit der Tool-Kombination [http://www.eclipse.org/ Eclipse] + [https://www.segger.com/jlink-debug-probes.html Segger JLink] + [https://launchpad.net/gcc-arm-embedded GCC-ARM-Embedded] + GDB erläutert für Linux und Windows. Die Tools gibt es auch für Mac OS, entsprechende Hinweise zur Benutzung fehlen hier noch. Der J-Link ist zwar relativ teuer (ca. 50€ für Privatpersonen), dafür aber schnell und stabil, kennt (fast?) alle ARM's und funktioniert plattformübergreifend direkt mit der Software vom Hersteller. Diese Kombination ermöglicht:
* Nutzung der komfortablen und mächtigen Entwicklungsumgebung Eclipse, inkl. Code-Vervollständigung und vielen Plugins wie zB. für Versionsverwaltung
* Automatische Generierung von makefiles und Aufruf des Compilers, kein manuelles Bearbeiten erforderlich
* Graphisches und schnelles Flashen und Debugging über JLink und GDB
* Graphische Anzeige von Registerinhalten beim Debugging
* Optional: Ausgabe von Texten per printf direkt nach Eclipse
* Projekte können zwischen Betriebssystemen ausgetauscht werden, Workflow generell fast identisch
* Voller Support für FPU der Cortex-M4, voller Support für C++, kein Codesize-Limit
* Es werden generische C/C++ Projekte angelegt; dies ist zwar etwas komplizierter, bietet aber später mehr Einstellungsmöglichkeiten
* Die Software ist auch für kommerzielle Nutzung komplett gratis und bis auf JLink auch OpenSource. Nur der JLink-Adapter selber ist für kommerzielle Nutzung teurer (aber das ist er bei Verwendung mit anderen IDE's natürlich auch).
* Da die normale und keine angepasste Eclipse-Version verwendet wird, können in der selben Eclipse-Instanz auch Projekte für völlig andere Plattformen und Sprachen benutzt werden, wie z.B. C/C++ für den PC, Java, ruby usw.
Da Eclipse eine sehr vielseitige Entwicklungsumgebung ist, sind einige Schritte erforderlich, um das Projekt auf die speziellen Anforderungen der Embedded-Entwicklung anzupassen. Diese sind im Folgenden erläutert.
== Installation ==
Beim Durcharbeiten der nachfolgenden Anleitung ist es empfehlenswert auch immer wieder einen Blick auf die Anweisungen und Beschreibungen auf der [http://gnuarmeclipse.livius.net GNU ARM Eclipse Homepage] zu werfen, da die Vorgehensweise dort gut beschrieben ist und sich, je nach Plugin-Version, auch gelegentlich ändert.
=== JLink ===
Zunächst die aktuelle Version von der [https://www.segger.com/jlink-software.html JLink Software] herunterladen und installieren. Da es hier regelmäßig neue Versionen gibt, ist es empfehlenswert sich für die [https://www.segger.com/notification/subscribe.php?prodid=7 E-Mail-Benachrichtigung] für neue Versionen einzutragen. Das Installationsverzeichnis für später merken.
=== GCC-ARM-Embedded ===
Die aktuelle Version für das jeweilige Betriebssystem [https://launchpad.net/gcc-arm-embedded herunterladen] und entpacken. Es gibt zwar auch Versionen in der Paketverwaltung mancher Linux-Distributionen aber die sind oft veraltet. Dafür bitte einen kurzen Pfad '''ohne Leerzeichen''' verwenden:
* Windows: z.B. C:\gcc-arm-embedded
* Linux: z.B. "/home/username/gcc-arm-embedded"
Den Pfad für später merken.
=== Make ===
* Linux: Meistens vorinstalliert. Unter Ubuntu im Paket "build-essential" enthalten.
* Windows: Hier können die MinGW/MSYS Basis Tools verwendet werden:
** Dazu [http://sourceforge.net/projects/mingw/files/latest/download hier] den MinGW Installer herunterladen und ausführen.
** Als Installation Directory am besten "C:\MinGW" beibehalten.
** So oft "Continue" anklicken, bis der "MinGW Installation Manager" erscheint und eine Liste installierbarer Pakete anzeigt.
** In der Liste das Paket "msys-base" mit der rechten Maustaste anklicken und "Mark for Installation" anklicken
** Im Menü "Installation"->"Apply Changes" anklicken, und mit "Apply" bestätigen.
** Nachdem der Vorgang abgeschlossen ist, das Programm beenden
=== Pfade setzen ===
'''Vor''' dem Starten von Eclipse müssen dem System die Pfade der Kommandozeilentools bekannt gemacht werden:
* Windows:
** Rechte Maustaste auf den Arbeitsplatz klicken, "Eigenschaften" -> "Erweiterte Systemeinstellungen" -> "Umgebungsvariablen" anklicken.
** Im '''unteren''' Listenfeld den Eintrag "Path" suchen, auf "Bearbeiten" klicken
** Ans Ende des Textes ein Semikolon hängen (falls nicht schon vorhanden), und durch zwei Semikola getrennt die Pfade zur J-Link Installation, zur GCC-ARM-Embedded -Installation (plus "\bin") und zur MSYS-Installation '''anhängen'''. Also zum Beispiel folgenden Text anhängen (Version anpassen) und alles mit OK bestätigen:
<code>;C:\gcc-arm-embedded\bin;C:\Program Files (x86)\SEGGER\JLink_V500e;C:\MinGW\msys\1.0\bin</code>
** In einem '''danach''' erst gestarteten cmd.exe Fenster den Befehl "JLink" eingeben. Es sollte die Lizenzvereinbarung von Segger erscheinen (diese bestätigen), und im Terminal wieder "exit" eingeben. Funktioniert dies nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "make" eingeben. Es sollte ein Meldung in der Art von "make: *** No targets specified and no makefile found. Stop." erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
* Linux:
** Mit einem Texteditor die (versteckte) Datei ".profile" im Home-Verzeichnis öffnen bzw. anlegen falls nicht vorhanden. Folgende Zeile '''anhägen''' (Pfad anpassen):
<code>export PATH=$PATH:/home/username/gcc-arm-embedded/bin</code>
** Den Benutzer ab- und wieder anmelden
** In einem Terminal-Fenster "JLinkExe" eingeben. Es sollte sich die JLink-Software mit "SEGGER J-Link Commander V5.00c ('?' for help)" melden. Diese wieder mit "exit" beenden. Falls das nicht funktioniert, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
Die Umgebungsvariable muss nach jedem Update der JLink-Software neu gesetzt werden, da der Pfad die Versionsnummer enthält.
=== Eclipse ===
* Da Eclipse auf Java basiert, muss dies zuerst installiert werden:
** Windows: Den [http://www.java.com/de/download/ Installer herunterladen] und laufen lassen.
** Linux: Je nach Distribution unterschiedlich, für Ubuntu [http://wiki.ubuntuusers.de/Java/Installation/Oracle_Java/Java_8#Installation siehe hier]
* Die aktuelle Version von "Eclipse IDE for C/C++ Developers" [http://www.eclipse.org/downloads/ hier herunterladen]. Unter Linux ist eclipse zwar auch oft in der Paketverwaltung enthalten, diese Version ist aber meist stark veraltet. Das heruntergeladene Archiv muss nur in einen beliebigen Ordner entpackt werden und die enthaltene Programmdatei (Linux: "eclipse", Windows: "eclipse.exe") gestartet werden.
* Den beim ersten Start erscheinenden "Welcome" Tab schließen.
* Im Menü "Help"->"Install new software" anwählen, unter "Work With" die URL <nowiki>"http://gnuarmeclipse.sourceforge.net/updates"</nowiki> eingeben, Enter klicken, den in der Liste erscheinenden Eintrag "GNU ARM C/C++ Cross Development Tools" auswählen, und mit "Next" und "Finish" installieren. Die Sicherheitsabfrage über unsignierte Software bestätigen, und die Abfrage zum Neustart von Eclipse bestätigen. Die Installation dauert etwas, und funktioniert manchmal nicht wenn die Server überlastet sind. Dann einfach später noch einmal probieren.
* Nur Windows: Im Menü "Window"->"Preferences" anklicken, in der Baumstruktur des erscheinenden Fensters "Run"->"String Substitution" anwählen, die Zeile mit "jlink_path" auswählen, "Edit" anklicken, und unter "Value" den Pfad zur JLink-Installation, also zB. "C:\Program Files (x86)\SEGGER\JLink_V500e" eintragen. Alles mit OK schließen.
* In der Toolbar den Eintrag "Make the C/C++ Packs perspective visible" anklicken, und das Symbol mit den gelben Pfeilen ("Update the package definitions from all repositories") anklicken. Dieser Vorgang dauert einige Minuten.
* In der erscheinenden Baumstruktur im Tab "Packs" unter dem Punkt "Keil" die Mikrocontroller auswählen (Mehrfachauswahl mit der Strg-Taste möglich) für die man programmieren möchte (zB. "STM32F4xx_DFP"), und mit der rechten Maustaste und Klick auf "Install" installieren. Auch dies dauert etwas, der Fortschritt des Vorgangs wird etwas versteckt rechts unten im Fenster angezeigt.
* Danach wieder mit Klick auf den "C/C++" Button oben rechts in die C/C++ Ansicht wechseln.

=== Standard Peripheral Library vorbereiten ===
Um auf die Hardware-Register direkt zuzugreifen oder die Treiberfunktionen von ST zu verwenden, sowie für den Startup-Code & Linkerscript, wird die Library von ST benötigt.
* Zum Herunterladen die Produktseite des Mikrocontrollers aufrufen (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für STM32F407VG), "Design Resources" anklicken, unter dem Punkt "Related Tools and Software" den Eintrag im Stil von "STM32F4 DSP and standard peripherals library" finden (zB [http://www.st.com/web/en/catalog/tools/PF257901 hier] für STM32F4). Ganz unten findet sich der "Download" Button.
Leider ist das Archiv nicht gut strukturiert. Daher müssen die entsprechenden Dateien herausgesucht werden:
* Im enthaltenen Verzeichnis "Project/*** Templates" nach Dateien suchen, die auf *.ld enden und die herauskopieren, deren Name zum verwendeten Mikrocontroller passt, also z.B. "STM32F417IG_FLASH.ld" für den STM32F4. Diese ist das Linkerscript und wird später für jedes Projekt benötigt. Zur Sicherheit sollte diese Datei einmal im Texteditor geöffnet und auf Fehler überprüft werden (ST ist bekannt dafür hier Fehler zu machen):
** Die Speicher-Größen-Angaben der folgenden Zeilen sollten zum Datasheet passen (ggf. anpassen):
<pre>MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
}</pre>
** Die Angabe der Adresse der Initialen Stack-Adresse sieht oft so aus:
<pre>_estack = 0x2001FFFF; /* end of RAM */</pre>
**Dies ist '''falsch''' (ST weiß selber nicht wie der Cortex-M funktioniert). Die angegebene Adresse sollte Anfangsadresse des RAM's (immer 0x20000000) plus RAM-Größe (z.B. beim STM32F407 0x20000 Bytes) sein, also z.B. 0x20020000 für den STM32F407:
<pre>_estack = 0x20020000; /* end of RAM */</pre>
** Ist dies falsch, kann es später zu schwer auffindbaren Problemen im Zusammenhang mit z.B. Floatingpoint-Funktionsargumenten kommen.
* Im Archiv nach Dateien suchen, deren Namen mit "startup_stm32" beginnt. Eine der Dateien heraussuchen, deren Name zum Mikrocontroller passt, '''und''' deren enthaltendes Verzeichnis den Namen TrueSTUDIO trägt, also zB. "Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f40_41xxx.s". Diese Datei herauskopieren, sie ist der Startup-Code und wird später für jedes Projekt benötigt. Dabei die Dateiendung von ".s" auf ".S" ändern, denn sonst erkennt eclipse sie nicht.
* Im Verzeichnis "Project/*** Templates" die Datei "stm32f***_conf.h" herauskopieren. Diese wird für Einstellungen in der Treiber-Library benötigt.
* Alles außer dem Verzeichnis "Libraries" löschen.
* Im Verzeichnis "Libraries" (rekursiv) nach Dateien & Ordnern suchen, die "example" oder "template" im Namen tragen und alle löschen.
* Die Unterverzeichnisse "Documentation", "Lib", "RTOS", "SVD" löschen. Die Lizenz und Release Notes-Dateien stören zwar nicht, können aber auch gelöscht werden. Im Endeffekt werden nur die .c und .h Dateien benötigt. Die DSP_Lib kann auch gelöscht werden, wenn keine DSP-Funktionen benötigt werden (existiert onehin nur für Cortex-M4 Controller).
* Leider enthält die Library für alle STM32F4 die Treiber für sowohl den FMC als auch den FSMC, obwohl beide nicht in allen Varianten vorhanden sind. Diese Treiber verursachen Compilerfehler, wenn für den falschen Controller kompiliert. Daher muss die Datei "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fmc.c" gelöscht werden, wenn kein FMC vorhanden ist (wie beim STM32F40x), bzw. die "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fsmc.c" wenn kein FSMC vorhanden ist (wie beim STM32F42x).
* Danach sollte nur noch so eine Struktur übrig bleigen:
<pre>./STM32F4xx_StdPeriph_Driver
./STM32F4xx_StdPeriph_Driver/src - Hier liegt der Quellcode für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_wwdg.c
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_usart.c
...
./STM32F4xx_StdPeriph_Driver/inc - Hier liegen die Includes für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_wwdg.h
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_usart.h
...
./CMSIS
./CMSIS/Include - Hier liegen die Includes für den Prozessorkern (Cortex-M*)
./CMSIS/Include/core_sc300.h
./CMSIS/Include/core_sc000.h
...
./CMSIS/DSP_Lib/Source/TransformFunctions - Hier liegt die DSP-Library (optional)
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q31.c
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q15.c
...
./CMSIS/Device/ST/STM32F4xx/Include
./CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h - Dies ist die Include-Datei für das Clock Setup
./CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h - Dies ist die zentrale Include-Datei für die Register-Definitionen</pre>

* Soll die Standard Peripheral Library nicht genutzt werden, sondern nur direkt die Register-Definitionen, werden nur die letzten beiden Dateien benötigt sowie die im Verzeichnis CMSIS/Include.
* In der Datei "CMSIS/Device/ST/STM32***/Include/stm32f***.h" befindet sich ganz oben eine Präprozessor-Fallunterscheidung der Form
<syntaxhighlight lang="c">#if !defined (STM32F40_41xxx) && !defined (STM32F427_437xx) && !defined (STM32F429_439xx) && !defined (STM32F401xx) && !defined (STM32F411xE)
/* #define STM32F40_41xxx */ /*!< STM32F405RG, STM32F405VG, STM32F405ZG, STM32F415RG, STM32F415VG, STM32F415ZG,
STM32F407VG, STM32F407VE, STM32F407ZG, STM32F407ZE, STM32F407IG, STM32F407IE,
STM32F417VG, STM32F417VE, STM32F417ZG, STM32F417ZE, STM32F417IG and STM32F417IE Devices */

/* #define STM32F427_437xx */ /*!< STM32F427VG, STM32F427VI, STM32F427ZG, STM32F427ZI, STM32F427IG, STM32F427II,
STM32F437VG, STM32F437VI, STM32F437ZG, STM32F437ZI, STM32F437IG, STM32F437II Devices */

/* #define STM32F429_439xx */ /*!< STM32F429VG, STM32F429VI, STM32F429ZG, STM32F429ZI, STM32F429BG, STM32F429BI,
STM32F429NG, STM32F439NI, STM32F429IG, STM32F429II, STM32F439VG, STM32F439VI,
STM32F439ZG, STM32F439ZI, STM32F439BG, STM32F439BI, STM32F439NG, STM32F439NI,
STM32F439IG and STM32F439II Devices */

/* #define STM32F401xx */ /*!< STM32F401CB, STM32F401CC, STM32F401RB, STM32F401RC, STM32F401VB, STM32F401VC
STM32F401CD, STM32F401RD, STM32F401VD, STM32F401CExx, STM32F401RE and STM32F401VE Devices */

/* #define STM32F411xE */ /*!< STM32F411CD, STM32F411RD, STM32F411VD, STM32F411CE, STM32F411RE and STM32F411VE Devices */
#endif</syntaxhighlight>
Hier mithilfe des Kommentars das Präprozessor-Makro heraussuchen, das zum verwendeten Mikrocontroller passt, also z.B. "STM32F40_41xxx" für den STM32F407VG. Dieses kopieren und für später merken.

== Projekt erstellen ==
=== Clock-Konfiguration generieren ===
Zum Initialisieren des Takts wird eine spezielle Funktion benötigt, die je nach Art und Frequenz des Takts spezifisch erzeugt werden muss. ST bietet ein Tool, um diese Datei zu generieren:
* Auf der Produkt seite des Mikrocontrollers (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für den STM32F407VG) auf "Design Resources" klicken, und den Eintrag in der Art von "Clock configuration tool for STM32F40x/41x microcontrollers (AN3988)" finden.
* Die Datei herunterladen und mit MS Excel öffnen. Die gewünschte Clock-Konfiguration auswählen, und den Code generieren lassen. Die Datei zB unter dem Namen system_stm32f4xx.c speichern.
=== Eclipse Projekt konfigurieren ===
[[Datei:Eclipse STM32 Project.png|right|thumb|Fertiges Projekt in Eclipse geöffnet]]Neue Projekte werden über "File"->"New"->"Project..." angelegt.
* In der Baumstruktur "C/C++ -> C++ Project" auswählen. Im C++ Projekt kann man natürlich auch einfachen C Code schreiben, aber es ist die Möglichkeit für C++ offen gehalten.
* In der Baumstruktur "Empty Project" auswählen, und rechts "Cross ARM GCC". Es können zwar auch die einfacheren Vorlagen für spezifische Controller wie "STM32F4xx C/C++ Project" verwendet werden, dies ist aber weniger flexibel, weswegen hier ersteres erläutert wird.
* Als Namen bitte einen ohne Leerzeichen oder Sonderzeichen verwenden.
* Mit 2x "Next" und 1x "Finish" das Erstellen abschließen.
* Das zuvor gesicherte Linkerscript (mit der Endung .ld) in das Projektverzeichnis kopieren. Den Projektnamen links anklicken, rechts Maustaste, und "Refresh" (oder F5) drücken. Das Linker-Script sollte im Dateibaum erscheinen.
* Im Projekt müssen zunächst einige Einstellungen vorgenommen werden. Dazu mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
** Im erscheinenden Fenster, im DropDown Menü oben "[All Configurations]" auswählen
** Nur Linux: In der Baumstruktur "C/C++ Build" auswählen, den Reiter "Behaviour" öffnen, den Haken bei "Enable Parallel Build" setzen. Dies beschleunigt die Kompilierung, funktioniert aber nicht unter Windows (beim Kopieren des Projekts beachten).
** In der Baumstruktur "C/C++ Build" -> "Settings" anwählen. Das Öffnen dauert in aktuellen Versionen etwas, vermutlich ein Bug.
*** In der 2. Baumstruktur "Target processor" auswählen.
**** Unter "ARM family" den gewünschten Prozessor auswählen, also z.B. "cortex-m4" für STMF4 oder "cortex-m3" für STM32F1.
**** Nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Unter Float ABI "FP instructions (hard)" auswählen
***** Unter "FPU Type" "fpv4-sp-d16 " auswählen. Siehe [https://launchpadlibrarian.net/209775724/readme.txt hier in der Tabelle] für die möglichen Werte der verschiedenen Prozessoren.
*** Es ist zu empfehlen, LTO beim Kompilieren im Release-Modus zu aktivieren. Dies resultiert in kleineren und schnelleren Binaries, erschwert aber das Debugging mit GDB sehr:
**** Oben die Configuration "Release" auswählen
**** In der 2. Baumstruktur "Optimization" auswählen
**** "Link-time optimizer (-flto)" aktivieren
**** Oben wieder "[All configurations]" anklicken
*** In der 2. Baumstruktur "Cross ARM C++ Compiler -> Optimization" anklicken
**** Rechts "Do not use exceptions (-fno-exceptions) anwählen
**** Rechts "Do not use RTTO (-fno-rtti)" anwählen
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "General" auswählen
**** In der Toolbar auf "Add" klicken, auf "Workspace" klicken, und das soeben in das Projekt kopierte Linkerscript auswählen.
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "Miscellaneous" auswählen
**** Den Haken bei "Use newlib-nano (--specs=nano.specs)" setzen.
**** Optional, nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Den Haken bei "Use float with with nano printf (-u _printf_float)" setzen. Dies ermöglicht die Nutzung von "%f" bei "printf", verbraucht aber automatisch eine Menge Flash+RAM und benötigt die Syscalls für malloc (s.u.). Daher ist ggf. zu empfehlen, dies nur in der Debug-Konfiguration zu aktivieren. Dazu in der Dropbown-Box oben vor aktivieren dieser Einstellung auf "Debug" klicken, und danach wieder auf "[All Configurations]".
*** Im Reiter "Devices" in der Baumstruktur den verwendeten Mikrocontroller, wie zB "STM32F407VG" auswählen.
** In der linken Baumstruktur "C/C++ General"->"Paths and Symbols" auswählen
*** Oben im Drop-Down-Menü "Debug" anklicken
*** Im Reiter "Symbols" rechts auf "Add" klicken und dadurch nacheinander folgende Symbole definieren. Dabei immer beide Häkchen setzen!
**** Name "HSE_VALUE" Value=Takt des Quarzes, z.B. 8000000
**** Name "USE_STDPERIPH_DRIVER" Value leerlassen
**** Name "__FPU_PRESENT" Value=1
**** Das zuvor gemerkte Präprozessor-Makro aus der "stm32f**.h" (zB. STM32F40_41xxx) Value leerlassen
**** Name "ARM_MATH_CM4", "ARM_MATH_CM3", "ARM_MATH_CM0", oder "ARM_MATH_CM0PLUS" je nachdem ob für den Cortex-M4, -M3, -M0, oder -M0+ kompiliert wird; Value leerlassen
** Das Fenster mit OK schließen.
Nun ist der Compiler an sich richtig konfiguriert. Allerdings fehlt noch die Library von ST:
* Die zuvor vorbereitete Standard Peripheral Library (d.h. das Verzeichnis "Libraries") in das Projektverzeichnis kopieren. Dies ist leider die einzig sinnvolle & einfache Möglichkeit.
* Den zuvor gesicherten Startup-Code, also zB. "startup_stm32f40_41xxx.S" in das Projektverzeichnis kopieren
* Die zuvor gesicherte Datei "stm32f***_conf.h" in das Projektverzeichnis kopieren
* Die zuvor generierte Datei "system_stm32f**" mit der Clock-Konfiguration in das Projektverzeichnis kopieren
Jetzt müssen dem Compiler noch die Pfade der Header-Dateien der Library mitgeteilt werden:
* Mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
* Links in der Baumstruktur "C/C++ General" -> "Paths and Symbols" anklicken, und den Reiter "Includes" auswählen.
* Oben im Drop-Down-Menü "Debug" auswählen.
* Mit "Add" nacheinander folgende Pfade hinzufügen. Dazu jeweils "Add to all languages" sowie "Add to all configurations" einschalten, und den "Workspace..." Button verwenden.
** "Libraries/CMSIS/Device/ST/STM32F***/Include"
** "Libraries/CMSIS/Include"
** "Libraries/STM32F**_StdPeriph_Driver/inc"
** Den Pfad, in dem sich die "stm32f***_conf.h" befindet, also typischerweise das Projektverzeichnis selber.
* Mit OK das Fenster schließen. Danach wird Eclipse die C/C++ Analyse laufen lassen. Dies kann etwas dauern und die weitere Bedienung währenddessen verlangsamen. Der Fortschritt ist unten rechts im Fenster zu sehen.

=== Linkerscript anpassen ===
Noch einmal das soeben hineinkopierte Linkerscript (mit der Endung .ld) öffnen. Die Zeile mit "_Min_Heap_Size" gibt die Größe des Heaps, d.h. des für malloc() zur Verfügung stehenden Speichers an. Wird malloc() nicht verwendet, kann dies auf 0 gesetzt werden. Soll printf() verwendet werden, ist zu empfehlen hier mindestens 2048 anzugeben, da printf sonst schnell keinen Speicher mehr hat und es zu komischem Verhalten kommt:
<pre>_Min_Heap_Size = 2048; /* required amount of heap */</pre>

=== Optional: Syscalls implementieren ===
Soll im Code printf() und/oder malloc() verwendet werden können, müssen die [https://sourceware.org/newlib/libc.html#Syscalls Syscalls der C-Library] implementiert werden. Dazu ist es empfehlenswert, [[Media:Newlib cortexm syscalls.c|diesen Beispielcode]] zu verwenden und in das Projektverzeichnis zu kopieren. Er gibt per printf() ausgebenen Texte seriell per SWO aus. Dies ist ein Extra-Pin im SWD-Debug-Interface (bei JTAG nicht verfügbar), der vom JLink eingelesen und über die JLink-Software an Eclipse geschickt wird. Der Code kann auch angepasst werden um den Text zB per UART auszugeben.

== Code schreiben und kompilieren ==
Dem Projekt kann jetzt eine eigene Quellcodedatei hinzugefügt werden. Dazu mit der rechten Maustaste auf den Projektnamen klicken, "New"->"Source file" auswählen. Die Datei z.B. "main.c" (für C) oder "main.cpp" (für C++) nennen. [[Media:Stm32f4 eclipse example.c|Hier]] kann ein einfacher Beispielcode für den STM32F407 heruntergeladen werden (funktioniert sowohl mit C als auch C++), der eine LED am Pin PD15 blinken lässt (blaue LED auf dem [http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF252419 STM32F4 Discovery Board]). Der Code braucht auf jeden Fall eine "main()"-Funktion, sowie im Falle von C++ eine Funktion namens "__cxa_pure_virtual":
<syntaxhighlight lang="cpp">extern "C" void __cxa_pure_virtual () {
// This is an error callback for C++
__disable_irq ();
while (1) {
// Cause debugger breakpoint
asm volatile ("bkpt");
}
}</syntaxhighlight>
Wird die oben verlinkte syscalls.c Datei nicht eingebunden, wird außerdem auch noch eine _exit Funktion benötigt:
<syntaxhighlight lang="cpp">

#ifdef __cplusplus
extern "C"
void _exit(int) {
#else
void _exit (int status) {
((void) status);
#endif
// Stop controller in case of fatal error
__disable_irq ();
while (1) {
asm volatile ("bkpt");
}
__builtin_unreachable ();
}
</syntaxhighlight>
Dies sind Callbacks zur Fehlerbehandlung. Durch Überschreiben durch simples Blockieren des Controllers wird das Einbinden der komplexen Fehlerbehandlung der Standardbibliothek verhindert.
Danach kann der Code zum ersten Mal kompiliert werden. Dazu das Hammer-Symbol "Build" in der Toolbar benutzen. Fehlermeldungen sollten dem "Console" Fenster entnommen werden, da das "Problems" Fenster nicht immer korrekt funktioniert. Die erzeugten Dateien landen im Unterordner "Debug" bzw. "Release", je nachdem welche Konfiguration gewählt ist. Die generierte Datei mit der Endung .elf (zB Debug/MeinProjekt.elf) enthält den produzierten Code sowie alle Debug-Informationen. Es wird auch eine .hex Datei angelegt, die das erzeugte Flash-Image enthält.

== Debugging ==
=== Debug Configuration anlegen ===
Um den Code zu flashen und debuggen, wird eine Debug Configuration benötigt. Dazu im Menü auf "Run"->"Debug Configurations" klicken. Sollen sowohl Debug- als auch Release- Versionen so geflasht/debuggt werden, müssen mehrere Debug Configurations angelegt werden. Dazu ist es am einfachsten, eine anzulegen und mehrfach zu kopieren.
* Im erscheinenden Fenster in der Liste auf "GDB SEGGER J-Link Debugging" klicken, und oben auf das Symbol "New launch configuration".
* Im Reiter "Main", unter "C/C++ Application" den Pfad zum kompilierten ELF-File angeben, also zB "Debug/ProjektName.elf".
* Im Reiter "Startup" sollte "Enable SWO" aktiviert, und daneben die CPU-Frequenz in Hz angegeben werden (zB 168000000 für den STM32F4).
* Im Reiter "Common" kann in der Liste "Display in favorites menu" ein Haken bei "Debug" gesetzt werden. Dadurch ist diese Debug Configuration schneller über das Käfer-Symbol in der Toolbar im Hauptmenü zugänglich.
* Über "Apply" und "Close" das Fenster schließen.
=== Debug Session starten ===
[[Datei:Eclipse STM32 Debugging.png|right|thumb|Laufende Debug-Session]]* Auf das kleine schwarze Dreieck neben dem Käfer-Symbol ("Debug") in der Toolbar klicken, und die soeben angelegte Debug-Configuration auswählen. Eclipse wechselt nun in die Debug-Perspektive. Nach Beendigung der Debug-Session kann über den "C/C++"-Knopf oben rechts wieder in die normale Ansicht gewechselt werden.
* Es ist zu empfehlen die einzelnen Fenster der Ansicht so zu verschieben, dass mehr Code gleichzeitig sichtbar ist.
* Standardmäßig legt eclipse automatisch einen Breakpoint zu Beginn der "main" Funktion an.
* Über die Knöpfe "Resume", "Break", "Terminate" kann die Ausführung kontrolliert werden. Durch Doppelklick links neben eine Zeile werden Breakpoints gesetzt.
* Das ARM Plugin ermöglicht das Betrachten von Peripherie-Registern mit Trennung der einzelnen Felder. Dazu im Fenster "Peripherals" die Peripherie-Einheiten, deren Inhalt man betrachten möchte, auswählen. Im "Memory" Fenster werden dann die Register angezeigt. Die Ansicht wird immer nach jedem Ausführungsschritt aktualisiert, nicht immer sofort. Im Zweifelsfall also eine Zeile weiter laufen lassen, um die Ansicht zu aktualisieren.
* Ausgaben per "printf" erscheinen automatisch unten in der Konsole.

== Siehe auch ==
* [[STM32#Tutorials_f.C3.BCr_diverse_Tool-Kombinationen|Weitere Tutorials für STM32-IDE's]]
* [[ARM_GCC|Verwendung des GCC für Bare-Metal ARM]]
* [http://diller-technologies.de/stm32_wide.html Tutorial zur STM32 Programmierung]

STM32 Eclipse JLink Linux/Windows

2015-06-28T12:21:24Z

Kichi:

== Einführung ==
Da viele Tutorials zur Verwendung von Eclipse mit [[STM32]] auf relativ alten Tools aufsetzen, hier eine Anleitung mit aktuellem (2015) Stand. Hier wird die Programmierung von STM32 (ähnlich auch auf andere Cortex-M anwendbar) mit der Tool-Kombination [http://www.eclipse.org/ Eclipse] + [https://www.segger.com/jlink-debug-probes.html Segger JLink] + [https://launchpad.net/gcc-arm-embedded GCC-ARM-Embedded] + GDB erläutert für Linux und Windows. Die Tools gibt es auch für Mac OS, entsprechende Hinweise zur Benutzung fehlen hier noch. Der J-Link ist zwar relativ teuer (ca. 50€ für Privatpersonen), dafür aber schnell und stabil, kennt (fast?) alle ARM's und funktioniert plattformübergreifend direkt mit der Software vom Hersteller. Diese Kombination ermöglicht:
* Nutzung der komfortablen und mächtigen Entwicklungsumgebung Eclipse, inkl. Code-Vervollständigung und vielen Plugins wie zB. für Versionsverwaltung
* Automatische Generierung von makefiles und Aufruf des Compilers, kein manuelles Bearbeiten erforderlich
* Graphisches und schnelles Flashen und Debugging über JLink und GDB
* Graphische Anzeige von Registerinhalten beim Debugging
* Optional: Ausgabe von Texten per printf direkt nach Eclipse
* Projekte können zwischen Betriebssystemen ausgetauscht werden, Workflow generell fast identisch
* Voller Support für FPU der Cortex-M4, voller Support für C++, kein Codesize-Limit
* Es werden generische C/C++ Projekte angelegt; dies ist zwar etwas komplizierter, bietet aber später mehr Einstellungsmöglichkeiten
* Die Software ist auch für kommerzielle Nutzung komplett gratis und bis auf JLink auch OpenSource. Nur der JLink-Adapter selber ist für kommerzielle Nutzung teurer (aber das ist er bei Verwendung mit anderen IDE's natürlich auch).
* Da die normale und keine angepasste Eclipse-Version verwendet wird, können in der selben Eclipse-Instanz auch Projekte für völlig andere Plattformen und Sprachen benutzt werden, wie z.B. C/C++ für den PC, Java, ruby usw.
Da Eclipse eine sehr vielseitige Entwicklungsumgebung ist, sind einige Schritte erforderlich, um das Projekt auf die speziellen Anforderungen der Embedded-Entwicklung anzupassen. Diese sind im Folgenden erläutert.
== Installation ==
Parallel zu der nachfolgenden Anleitung ist es empfehlenswert, bei der Einrichtung immer wieder einen Blick auf die Anweisungen und Beschreibungen auf der [http://gnuarmeclipse.livius.net GNU ARM Eclipse Homepage] zu werfen, da die Vorgehensweise dort gut beschrieben ist und sich auch gelegentlich ändert.
=== JLink ===
Zunächst die aktuelle Version von der [https://www.segger.com/jlink-software.html JLink Software] herunterladen und installieren. Da es hier regelmäßig neue Versionen gibt, ist es empfehlenswert sich für die [https://www.segger.com/notification/subscribe.php?prodid=7 E-Mail-Benachrichtigung] für neue Versionen einzutragen. Das Installationsverzeichnis für später merken.
=== GCC-ARM-Embedded ===
Die aktuelle Version für das jeweilige Betriebssystem [https://launchpad.net/gcc-arm-embedded herunterladen] und entpacken. Es gibt zwar auch Versionen in der Paketverwaltung mancher Linux-Distributionen aber die sind oft veraltet. Dafür bitte einen kurzen Pfad '''ohne Leerzeichen''' verwenden:
* Windows: z.B. C:\gcc-arm-embedded
* Linux: z.B. "/home/username/gcc-arm-embedded"
Den Pfad für später merken.
=== Make ===
* Linux: Meistens vorinstalliert. Unter Ubuntu im Paket "build-essential" enthalten.
* Windows: Hier können die MinGW/MSYS Basis Tools verwendet werden:
** Dazu [http://sourceforge.net/projects/mingw/files/latest/download hier] den MinGW Installer herunterladen und ausführen.
** Als Installation Directory am besten "C:\MinGW" beibehalten.
** So oft "Continue" anklicken, bis der "MinGW Installation Manager" erscheint und eine Liste installierbarer Pakete anzeigt.
** In der Liste das Paket "msys-base" mit der rechten Maustaste anklicken und "Mark for Installation" anklicken
** Im Menü "Installation"->"Apply Changes" anklicken, und mit "Apply" bestätigen.
** Nachdem der Vorgang abgeschlossen ist, das Programm beenden
=== Pfade setzen ===
'''Vor''' dem Starten von Eclipse müssen dem System die Pfade der Kommandozeilentools bekannt gemacht werden:
* Windows:
** Rechte Maustaste auf den Arbeitsplatz klicken, "Eigenschaften" -> "Erweiterte Systemeinstellungen" -> "Umgebungsvariablen" anklicken.
** Im '''unteren''' Listenfeld den Eintrag "Path" suchen, auf "Bearbeiten" klicken
** Ans Ende des Textes ein Semikolon hängen (falls nicht schon vorhanden), und durch zwei Semikola getrennt die Pfade zur J-Link Installation, zur GCC-ARM-Embedded -Installation (plus "\bin") und zur MSYS-Installation '''anhängen'''. Also zum Beispiel folgenden Text anhängen (Version anpassen) und alles mit OK bestätigen:
<code>;C:\gcc-arm-embedded\bin;C:\Program Files (x86)\SEGGER\JLink_V500e;C:\MinGW\msys\1.0\bin</code>
** In einem '''danach''' erst gestarteten cmd.exe Fenster den Befehl "JLink" eingeben. Es sollte die Lizenzvereinbarung von Segger erscheinen (diese bestätigen), und im Terminal wieder "exit" eingeben. Funktioniert dies nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "make" eingeben. Es sollte ein Meldung in der Art von "make: *** No targets specified and no makefile found. Stop." erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
* Linux:
** Mit einem Texteditor die (versteckte) Datei ".profile" im Home-Verzeichnis öffnen bzw. anlegen falls nicht vorhanden. Folgende Zeile '''anhägen''' (Pfad anpassen):
<code>export PATH=$PATH:/home/username/gcc-arm-embedded/bin</code>
** Den Benutzer ab- und wieder anmelden
** In einem Terminal-Fenster "JLinkExe" eingeben. Es sollte sich die JLink-Software mit "SEGGER J-Link Commander V5.00c ('?' for help)" melden. Diese wieder mit "exit" beenden. Falls das nicht funktioniert, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
Die Umgebungsvariable muss nach jedem Update der JLink-Software neu gesetzt werden, da der Pfad die Versionsnummer enthält.
=== Eclipse ===
* Da Eclipse auf Java basiert, muss dies zuerst installiert werden:
** Windows: Den [http://www.java.com/de/download/ Installer herunterladen] und laufen lassen.
** Linux: Je nach Distribution unterschiedlich, für Ubuntu [http://wiki.ubuntuusers.de/Java/Installation/Oracle_Java/Java_8#Installation siehe hier]
* Die aktuelle Version von "Eclipse IDE for C/C++ Developers" [http://www.eclipse.org/downloads/ hier herunterladen]. Unter Linux ist eclipse zwar auch oft in der Paketverwaltung enthalten, diese Version ist aber meist stark veraltet. Das heruntergeladene Archiv muss nur in einen beliebigen Ordner entpackt werden und die enthaltene Programmdatei (Linux: "eclipse", Windows: "eclipse.exe") gestartet werden.
* Den beim ersten Start erscheinenden "Welcome" Tab schließen.
* Im Menü "Help"->"Install new software" anwählen, unter "Work With" die URL <nowiki>"http://gnuarmeclipse.sourceforge.net/updates"</nowiki> eingeben, Enter klicken, den in der Liste erscheinenden Eintrag "GNU ARM C/C++ Cross Development Tools" auswählen, und mit "Next" und "Finish" installieren. Die Sicherheitsabfrage über unsignierte Software bestätigen, und die Abfrage zum Neustart von Eclipse bestätigen. Die Installation dauert etwas, und funktioniert manchmal nicht wenn die Server überlastet sind. Dann einfach später noch einmal probieren.
* Nur Windows: Im Menü "Window"->"Preferences" anklicken, in der Baumstruktur des erscheinenden Fensters "Run"->"String Substitution" anwählen, die Zeile mit "jlink_path" auswählen, "Edit" anklicken, und unter "Value" den Pfad zur JLink-Installation, also zB. "C:\Program Files (x86)\SEGGER\JLink_V500e" eintragen. Alles mit OK schließen.
* In der Toolbar den Eintrag "Make the C/C++ Packs perspective visible" anklicken, und das Symbol mit den gelben Pfeilen ("Update the package definitions from all repositories") anklicken. Dieser Vorgang dauert einige Minuten.
* In der erscheinenden Baumstruktur im Tab "Packs" unter dem Punkt "Keil" die Mikrocontroller auswählen (Mehrfachauswahl mit der Strg-Taste möglich) für die man programmieren möchte (zB. "STM32F4xx_DFP"), und mit der rechten Maustaste und Klick auf "Install" installieren. Auch dies dauert etwas, der Fortschritt des Vorgangs wird etwas versteckt rechts unten im Fenster angezeigt.
* Danach wieder mit Klick auf den "C/C++" Button oben rechts in die C/C++ Ansicht wechseln.

=== Standard Peripheral Library vorbereiten ===
Um auf die Hardware-Register direkt zuzugreifen oder die Treiberfunktionen von ST zu verwenden, sowie für den Startup-Code & Linkerscript, wird die Library von ST benötigt.
* Zum Herunterladen die Produktseite des Mikrocontrollers aufrufen (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für STM32F407VG), "Design Resources" anklicken, unter dem Punkt "Related Tools and Software" den Eintrag im Stil von "STM32F4 DSP and standard peripherals library" finden (zB [http://www.st.com/web/en/catalog/tools/PF257901 hier] für STM32F4). Ganz unten findet sich der "Download" Button.
Leider ist das Archiv nicht gut strukturiert. Daher müssen die entsprechenden Dateien herausgesucht werden:
* Im enthaltenen Verzeichnis "Project/*** Templates" nach Dateien suchen, die auf *.ld enden und die herauskopieren, deren Name zum verwendeten Mikrocontroller passt, also z.B. "STM32F417IG_FLASH.ld" für den STM32F4. Diese ist das Linkerscript und wird später für jedes Projekt benötigt. Zur Sicherheit sollte diese Datei einmal im Texteditor geöffnet und auf Fehler überprüft werden (ST ist bekannt dafür hier Fehler zu machen):
** Die Speicher-Größen-Angaben der folgenden Zeilen sollten zum Datasheet passen (ggf. anpassen):
<pre>MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
}</pre>
** Die Angabe der Adresse der Initialen Stack-Adresse sieht oft so aus:
<pre>_estack = 0x2001FFFF; /* end of RAM */</pre>
**Dies ist '''falsch''' (ST weiß selber nicht wie der Cortex-M funktioniert). Die angegebene Adresse sollte Anfangsadresse des RAM's (immer 0x20000000) plus RAM-Größe (z.B. beim STM32F407 0x20000 Bytes) sein, also z.B. 0x20020000 für den STM32F407:
<pre>_estack = 0x20020000; /* end of RAM */</pre>
** Ist dies falsch, kann es später zu schwer auffindbaren Problemen im Zusammenhang mit z.B. Floatingpoint-Funktionsargumenten kommen.
* Im Archiv nach Dateien suchen, deren Namen mit "startup_stm32" beginnt. Eine der Dateien heraussuchen, deren Name zum Mikrocontroller passt, '''und''' deren enthaltendes Verzeichnis den Namen TrueSTUDIO trägt, also zB. "Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f40_41xxx.s". Diese Datei herauskopieren, sie ist der Startup-Code und wird später für jedes Projekt benötigt. Dabei die Dateiendung von ".s" auf ".S" ändern, denn sonst erkennt eclipse sie nicht.
* Im Verzeichnis "Project/*** Templates" die Datei "stm32f***_conf.h" herauskopieren. Diese wird für Einstellungen in der Treiber-Library benötigt.
* Alles außer dem Verzeichnis "Libraries" löschen.
* Im Verzeichnis "Libraries" (rekursiv) nach Dateien & Ordnern suchen, die "example" oder "template" im Namen tragen und alle löschen.
* Die Unterverzeichnisse "Documentation", "Lib", "RTOS", "SVD" löschen. Die Lizenz und Release Notes-Dateien stören zwar nicht, können aber auch gelöscht werden. Im Endeffekt werden nur die .c und .h Dateien benötigt. Die DSP_Lib kann auch gelöscht werden, wenn keine DSP-Funktionen benötigt werden (existiert onehin nur für Cortex-M4 Controller).
* Leider enthält die Library für alle STM32F4 die Treiber für sowohl den FMC als auch den FSMC, obwohl beide nicht in allen Varianten vorhanden sind. Diese Treiber verursachen Compilerfehler, wenn für den falschen Controller kompiliert. Daher muss die Datei "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fmc.c" gelöscht werden, wenn kein FMC vorhanden ist (wie beim STM32F40x), bzw. die "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fsmc.c" wenn kein FSMC vorhanden ist (wie beim STM32F42x).
* Danach sollte nur noch so eine Struktur übrig bleigen:
<pre>./STM32F4xx_StdPeriph_Driver
./STM32F4xx_StdPeriph_Driver/src - Hier liegt der Quellcode für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_wwdg.c
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_usart.c
...
./STM32F4xx_StdPeriph_Driver/inc - Hier liegen die Includes für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_wwdg.h
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_usart.h
...
./CMSIS
./CMSIS/Include - Hier liegen die Includes für den Prozessorkern (Cortex-M*)
./CMSIS/Include/core_sc300.h
./CMSIS/Include/core_sc000.h
...
./CMSIS/DSP_Lib/Source/TransformFunctions - Hier liegt die DSP-Library (optional)
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q31.c
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q15.c
...
./CMSIS/Device/ST/STM32F4xx/Include
./CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h - Dies ist die Include-Datei für das Clock Setup
./CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h - Dies ist die zentrale Include-Datei für die Register-Definitionen</pre>

* Soll die Standard Peripheral Library nicht genutzt werden, sondern nur direkt die Register-Definitionen, werden nur die letzten beiden Dateien benötigt sowie die im Verzeichnis CMSIS/Include.
* In der Datei "CMSIS/Device/ST/STM32***/Include/stm32f***.h" befindet sich ganz oben eine Präprozessor-Fallunterscheidung der Form
<syntaxhighlight lang="c">#if !defined (STM32F40_41xxx) && !defined (STM32F427_437xx) && !defined (STM32F429_439xx) && !defined (STM32F401xx) && !defined (STM32F411xE)
/* #define STM32F40_41xxx */ /*!< STM32F405RG, STM32F405VG, STM32F405ZG, STM32F415RG, STM32F415VG, STM32F415ZG,
STM32F407VG, STM32F407VE, STM32F407ZG, STM32F407ZE, STM32F407IG, STM32F407IE,
STM32F417VG, STM32F417VE, STM32F417ZG, STM32F417ZE, STM32F417IG and STM32F417IE Devices */

/* #define STM32F427_437xx */ /*!< STM32F427VG, STM32F427VI, STM32F427ZG, STM32F427ZI, STM32F427IG, STM32F427II,
STM32F437VG, STM32F437VI, STM32F437ZG, STM32F437ZI, STM32F437IG, STM32F437II Devices */

/* #define STM32F429_439xx */ /*!< STM32F429VG, STM32F429VI, STM32F429ZG, STM32F429ZI, STM32F429BG, STM32F429BI,
STM32F429NG, STM32F439NI, STM32F429IG, STM32F429II, STM32F439VG, STM32F439VI,
STM32F439ZG, STM32F439ZI, STM32F439BG, STM32F439BI, STM32F439NG, STM32F439NI,
STM32F439IG and STM32F439II Devices */

/* #define STM32F401xx */ /*!< STM32F401CB, STM32F401CC, STM32F401RB, STM32F401RC, STM32F401VB, STM32F401VC
STM32F401CD, STM32F401RD, STM32F401VD, STM32F401CExx, STM32F401RE and STM32F401VE Devices */

/* #define STM32F411xE */ /*!< STM32F411CD, STM32F411RD, STM32F411VD, STM32F411CE, STM32F411RE and STM32F411VE Devices */
#endif</syntaxhighlight>
Hier mithilfe des Kommentars das Präprozessor-Makro heraussuchen, das zum verwendeten Mikrocontroller passt, also z.B. "STM32F40_41xxx" für den STM32F407VG. Dieses kopieren und für später merken.

== Projekt erstellen ==
=== Clock-Konfiguration generieren ===
Zum Initialisieren des Takts wird eine spezielle Funktion benötigt, die je nach Art und Frequenz des Takts spezifisch erzeugt werden muss. ST bietet ein Tool, um diese Datei zu generieren:
* Auf der Produkt seite des Mikrocontrollers (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für den STM32F407VG) auf "Design Resources" klicken, und den Eintrag in der Art von "Clock configuration tool for STM32F40x/41x microcontrollers (AN3988)" finden.
* Die Datei herunterladen und mit MS Excel öffnen. Die gewünschte Clock-Konfiguration auswählen, und den Code generieren lassen. Die Datei zB unter dem Namen system_stm32f4xx.c speichern.
=== Eclipse Projekt konfigurieren ===
[[Datei:Eclipse STM32 Project.png|right|thumb|Fertiges Projekt in Eclipse geöffnet]]Neue Projekte werden über "File"->"New"->"Project..." angelegt.
* In der Baumstruktur "C/C++ -> C++ Project" auswählen. Im C++ Projekt kann man natürlich auch einfachen C Code schreiben, aber es ist die Möglichkeit für C++ offen gehalten.
* In der Baumstruktur "Empty Project" auswählen, und rechts "Cross ARM GCC". Es können zwar auch die einfacheren Vorlagen für spezifische Controller wie "STM32F4xx C/C++ Project" verwendet werden, dies ist aber weniger flexibel, weswegen hier ersteres erläutert wird.
* Als Namen bitte einen ohne Leerzeichen oder Sonderzeichen verwenden.
* Mit 2x "Next" und 1x "Finish" das Erstellen abschließen.
* Das zuvor gesicherte Linkerscript (mit der Endung .ld) in das Projektverzeichnis kopieren. Den Projektnamen links anklicken, rechts Maustaste, und "Refresh" (oder F5) drücken. Das Linker-Script sollte im Dateibaum erscheinen.
* Im Projekt müssen zunächst einige Einstellungen vorgenommen werden. Dazu mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
** Im erscheinenden Fenster, im DropDown Menü oben "[All Configurations]" auswählen
** Nur Linux: In der Baumstruktur "C/C++ Build" auswählen, den Reiter "Behaviour" öffnen, den Haken bei "Enable Parallel Build" setzen. Dies beschleunigt die Kompilierung, funktioniert aber nicht unter Windows (beim Kopieren des Projekts beachten).
** In der Baumstruktur "C/C++ Build" -> "Settings" anwählen. Das Öffnen dauert in aktuellen Versionen etwas, vermutlich ein Bug.
*** In der 2. Baumstruktur "Target processor" auswählen.
**** Unter "ARM family" den gewünschten Prozessor auswählen, also z.B. "cortex-m4" für STMF4 oder "cortex-m3" für STM32F1.
**** Nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Unter Float ABI "FP instructions (hard)" auswählen
***** Unter "FPU Type" "fpv4-sp-d16 " auswählen. Siehe [https://launchpadlibrarian.net/209775724/readme.txt hier in der Tabelle] für die möglichen Werte der verschiedenen Prozessoren.
*** Es ist zu empfehlen, LTO beim Kompilieren im Release-Modus zu aktivieren. Dies resultiert in kleineren und schnelleren Binaries, erschwert aber das Debugging mit GDB sehr:
**** Oben die Configuration "Release" auswählen
**** In der 2. Baumstruktur "Optimization" auswählen
**** "Link-time optimizer (-flto)" aktivieren
**** Oben wieder "[All configurations]" anklicken
*** In der 2. Baumstruktur "Cross ARM C++ Compiler -> Optimization" anklicken
**** Rechts "Do not use exceptions (-fno-exceptions) anwählen
**** Rechts "Do not use RTTO (-fno-rtti)" anwählen
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "General" auswählen
**** In der Toolbar auf "Add" klicken, auf "Workspace" klicken, und das soeben in das Projekt kopierte Linkerscript auswählen.
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "Miscellaneous" auswählen
**** Den Haken bei "Use newlib-nano (--specs=nano.specs)" setzen.
**** Optional, nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Den Haken bei "Use float with with nano printf (-u _printf_float)" setzen. Dies ermöglicht die Nutzung von "%f" bei "printf", verbraucht aber automatisch eine Menge Flash+RAM und benötigt die Syscalls für malloc (s.u.). Daher ist ggf. zu empfehlen, dies nur in der Debug-Konfiguration zu aktivieren. Dazu in der Dropbown-Box oben vor aktivieren dieser Einstellung auf "Debug" klicken, und danach wieder auf "[All Configurations]".
*** Im Reiter "Devices" in der Baumstruktur den verwendeten Mikrocontroller, wie zB "STM32F407VG" auswählen.
** In der linken Baumstruktur "C/C++ General"->"Paths and Symbols" auswählen
*** Oben im Drop-Down-Menü "Debug" anklicken
*** Im Reiter "Symbols" rechts auf "Add" klicken und dadurch nacheinander folgende Symbole definieren. Dabei immer beide Häkchen setzen!
**** Name "HSE_VALUE" Value=Takt des Quarzes, z.B. 8000000
**** Name "USE_STDPERIPH_DRIVER" Value leerlassen
**** Name "__FPU_PRESENT" Value=1
**** Das zuvor gemerkte Präprozessor-Makro aus der "stm32f**.h" (zB. STM32F40_41xxx) Value leerlassen
**** Name "ARM_MATH_CM4", "ARM_MATH_CM3", "ARM_MATH_CM0", oder "ARM_MATH_CM0PLUS" je nachdem ob für den Cortex-M4, -M3, -M0, oder -M0+ kompiliert wird; Value leerlassen
** Das Fenster mit OK schließen.
Nun ist der Compiler an sich richtig konfiguriert. Allerdings fehlt noch die Library von ST:
* Die zuvor vorbereitete Standard Peripheral Library (d.h. das Verzeichnis "Libraries") in das Projektverzeichnis kopieren. Dies ist leider die einzig sinnvolle & einfache Möglichkeit.
* Den zuvor gesicherten Startup-Code, also zB. "startup_stm32f40_41xxx.S" in das Projektverzeichnis kopieren
* Die zuvor gesicherte Datei "stm32f***_conf.h" in das Projektverzeichnis kopieren
* Die zuvor generierte Datei "system_stm32f**" mit der Clock-Konfiguration in das Projektverzeichnis kopieren
Jetzt müssen dem Compiler noch die Pfade der Header-Dateien der Library mitgeteilt werden:
* Mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
* Links in der Baumstruktur "C/C++ General" -> "Paths and Symbols" anklicken, und den Reiter "Includes" auswählen.
* Oben im Drop-Down-Menü "Debug" auswählen.
* Mit "Add" nacheinander folgende Pfade hinzufügen. Dazu jeweils "Add to all languages" sowie "Add to all configurations" einschalten, und den "Workspace..." Button verwenden.
** "Libraries/CMSIS/Device/ST/STM32F***/Include"
** "Libraries/CMSIS/Include"
** "Libraries/STM32F**_StdPeriph_Driver/inc"
** Den Pfad, in dem sich die "stm32f***_conf.h" befindet, also typischerweise das Projektverzeichnis selber.
* Mit OK das Fenster schließen. Danach wird Eclipse die C/C++ Analyse laufen lassen. Dies kann etwas dauern und die weitere Bedienung währenddessen verlangsamen. Der Fortschritt ist unten rechts im Fenster zu sehen.

=== Linkerscript anpassen ===
Noch einmal das soeben hineinkopierte Linkerscript (mit der Endung .ld) öffnen. Die Zeile mit "_Min_Heap_Size" gibt die Größe des Heaps, d.h. des für malloc() zur Verfügung stehenden Speichers an. Wird malloc() nicht verwendet, kann dies auf 0 gesetzt werden. Soll printf() verwendet werden, ist zu empfehlen hier mindestens 2048 anzugeben, da printf sonst schnell keinen Speicher mehr hat und es zu komischem Verhalten kommt:
<pre>_Min_Heap_Size = 2048; /* required amount of heap */</pre>

=== Optional: Syscalls implementieren ===
Soll im Code printf() und/oder malloc() verwendet werden können, müssen die [https://sourceware.org/newlib/libc.html#Syscalls Syscalls der C-Library] implementiert werden. Dazu ist es empfehlenswert, [[Media:Newlib cortexm syscalls.c|diesen Beispielcode]] zu verwenden und in das Projektverzeichnis zu kopieren. Er gibt per printf() ausgebenen Texte seriell per SWO aus. Dies ist ein Extra-Pin im SWD-Debug-Interface (bei JTAG nicht verfügbar), der vom JLink eingelesen und über die JLink-Software an Eclipse geschickt wird. Der Code kann auch angepasst werden um den Text zB per UART auszugeben.

== Code schreiben und kompilieren ==
Dem Projekt kann jetzt eine eigene Quellcodedatei hinzugefügt werden. Dazu mit der rechten Maustaste auf den Projektnamen klicken, "New"->"Source file" auswählen. Die Datei z.B. "main.c" (für C) oder "main.cpp" (für C++) nennen. [[Media:Stm32f4 eclipse example.c|Hier]] kann ein einfacher Beispielcode für den STM32F407 heruntergeladen werden (funktioniert sowohl mit C als auch C++), der eine LED am Pin PD15 blinken lässt (blaue LED auf dem [http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF252419 STM32F4 Discovery Board]). Der Code braucht auf jeden Fall eine "main()"-Funktion, sowie im Falle von C++ eine Funktion namens "__cxa_pure_virtual":
<syntaxhighlight lang="cpp">extern "C" void __cxa_pure_virtual () {
// This is an error callback for C++
__disable_irq ();
while (1) {
// Cause debugger breakpoint
asm volatile ("bkpt");
}
}</syntaxhighlight>
Wird die oben verlinkte syscalls.c Datei nicht eingebunden, wird außerdem auch noch eine _exit Funktion benötigt:
<syntaxhighlight lang="cpp">

#ifdef __cplusplus
extern "C"
void _exit(int) {
#else
void _exit (int status) {
((void) status);
#endif
// Stop controller in case of fatal error
__disable_irq ();
while (1) {
asm volatile ("bkpt");
}
__builtin_unreachable ();
}
</syntaxhighlight>
Dies sind Callbacks zur Fehlerbehandlung. Durch Überschreiben durch simples Blockieren des Controllers wird das Einbinden der komplexen Fehlerbehandlung der Standardbibliothek verhindert.
Danach kann der Code zum ersten Mal kompiliert werden. Dazu das Hammer-Symbol "Build" in der Toolbar benutzen. Fehlermeldungen sollten dem "Console" Fenster entnommen werden, da das "Problems" Fenster nicht immer korrekt funktioniert. Die erzeugten Dateien landen im Unterordner "Debug" bzw. "Release", je nachdem welche Konfiguration gewählt ist. Die generierte Datei mit der Endung .elf (zB Debug/MeinProjekt.elf) enthält den produzierten Code sowie alle Debug-Informationen. Es wird auch eine .hex Datei angelegt, die das erzeugte Flash-Image enthält.

== Debugging ==
=== Debug Configuration anlegen ===
Um den Code zu flashen und debuggen, wird eine Debug Configuration benötigt. Dazu im Menü auf "Run"->"Debug Configurations" klicken. Sollen sowohl Debug- als auch Release- Versionen so geflasht/debuggt werden, müssen mehrere Debug Configurations angelegt werden. Dazu ist es am einfachsten, eine anzulegen und mehrfach zu kopieren.
* Im erscheinenden Fenster in der Liste auf "GDB SEGGER J-Link Debugging" klicken, und oben auf das Symbol "New launch configuration".
* Im Reiter "Main", unter "C/C++ Application" den Pfad zum kompilierten ELF-File angeben, also zB "Debug/ProjektName.elf".
* Im Reiter "Startup" sollte "Enable SWO" aktiviert, und daneben die CPU-Frequenz in Hz angegeben werden (zB 168000000 für den STM32F4).
* Im Reiter "Common" kann in der Liste "Display in favorites menu" ein Haken bei "Debug" gesetzt werden. Dadurch ist diese Debug Configuration schneller über das Käfer-Symbol in der Toolbar im Hauptmenü zugänglich.
* Über "Apply" und "Close" das Fenster schließen.
=== Debug Session starten ===
[[Datei:Eclipse STM32 Debugging.png|right|thumb|Laufende Debug-Session]]* Auf das kleine schwarze Dreieck neben dem Käfer-Symbol ("Debug") in der Toolbar klicken, und die soeben angelegte Debug-Configuration auswählen. Eclipse wechselt nun in die Debug-Perspektive. Nach Beendigung der Debug-Session kann über den "C/C++"-Knopf oben rechts wieder in die normale Ansicht gewechselt werden.
* Es ist zu empfehlen die einzelnen Fenster der Ansicht so zu verschieben, dass mehr Code gleichzeitig sichtbar ist.
* Standardmäßig legt eclipse automatisch einen Breakpoint zu Beginn der "main" Funktion an.
* Über die Knöpfe "Resume", "Break", "Terminate" kann die Ausführung kontrolliert werden. Durch Doppelklick links neben eine Zeile werden Breakpoints gesetzt.
* Das ARM Plugin ermöglicht das Betrachten von Peripherie-Registern mit Trennung der einzelnen Felder. Dazu im Fenster "Peripherals" die Peripherie-Einheiten, deren Inhalt man betrachten möchte, auswählen. Im "Memory" Fenster werden dann die Register angezeigt. Die Ansicht wird immer nach jedem Ausführungsschritt aktualisiert, nicht immer sofort. Im Zweifelsfall also eine Zeile weiter laufen lassen, um die Ansicht zu aktualisieren.
* Ausgaben per "printf" erscheinen automatisch unten in der Konsole.

== Siehe auch ==
* [[STM32#Tutorials_f.C3.BCr_diverse_Tool-Kombinationen|Weitere Tutorials für STM32-IDE's]]
* [[ARM_GCC|Verwendung des GCC für Bare-Metal ARM]]
* [http://diller-technologies.de/stm32_wide.html Tutorial zur STM32 Programmierung]

STM32 Eclipse JLink Linux/Windows

2015-06-28T12:14:48Z

Kichi: /* Einführung */

== Einführung ==
Da viele Tutorials zur Verwendung von Eclipse mit [[STM32]] auf relativ alten Tools aufsetzen, hier eine Anleitung mit aktuellem (2015) Stand. Hier wird die Programmierung von STM32 (ähnlich auch auf andere Cortex-M anwendbar) mit der Tool-Kombination [http://www.eclipse.org/ Eclipse] + [https://www.segger.com/jlink-debug-probes.html Segger JLink] + [https://launchpad.net/gcc-arm-embedded GCC-ARM-Embedded] + GDB erläutert für Linux und Windows. Die Tools gibt es auch für Mac OS, entsprechende Hinweise zur Benutzung fehlen hier noch. Der J-Link ist zwar relativ teuer (ca. 50€ für Privatpersonen), dafür aber schnell und stabil, kennt (fast?) alle ARM's und funktioniert plattformübergreifend direkt mit der Software vom Hersteller. Diese Kombination ermöglicht:
* Nutzung der komfortablen und mächtigen Entwicklungsumgebung Eclipse, inkl. Code-Vervollständigung und vielen Plugins wie zB. für Versionsverwaltung
* Automatische Generierung von makefiles und Aufruf des Compilers, kein manuelles Bearbeiten erforderlich
* Graphisches und schnelles Flashen und Debugging über JLink und GDB
* Graphische Anzeige von Registerinhalten beim Debugging
* Optional: Ausgabe von Texten per printf direkt nach Eclipse
* Projekte können zwischen Betriebssystemen ausgetauscht werden, Workflow generell fast identisch
* Voller Support für FPU der Cortex-M4, voller Support für C++, kein Codesize-Limit
* Es werden generische C/C++ Projekte angelegt; dies ist zwar etwas komplizierter, bietet aber später mehr Einstellungsmöglichkeiten
* Die Software ist auch für kommerzielle Nutzung komplett gratis und bis auf JLink auch OpenSource. Nur der JLink-Adapter selber ist für kommerzielle Nutzung teurer (aber das ist er bei Verwendung mit anderen IDE's natürlich auch).
* Da die normale und keine angepasste Eclipse-Version verwendet wird, können in der selben Eclipse-Instanz auch Projekte für völlig andere Plattformen und Sprachen benutzt werden, wie z.B. C/C++ für den PC, Java, ruby usw.
Da Eclipse eine sehr vielseitige Entwicklungsumgebung ist, sind einige Schritte erforderlich, um das Projekt auf die speziellen Anforderungen der Embedded-Entwicklung anzupassen. Diese sind im Folgenden erläutert.

Ebenfalls sehr empfehlenswert ist es, bei der Einrichtung immer wieder einen Blick auf die Anleitungen und Beschreibungen auf der [http://gnuarmeclipse.livius.net GNU ARM Eclipse Homepage] zu werfen, da die Vorgehensweise dort gut beschrieben ist und sich auch gelegentlich ändert.

== Installation ==
=== JLink ===
Zunächst die aktuelle Version von der [https://www.segger.com/jlink-software.html JLink Software] herunterladen und installieren. Da es hier regelmäßig neue Versionen gibt, ist es empfehlenswert sich für die [https://www.segger.com/notification/subscribe.php?prodid=7 E-Mail-Benachrichtigung] für neue Versionen einzutragen. Das Installationsverzeichnis für später merken.
=== GCC-ARM-Embedded ===
Die aktuelle Version für das jeweilige Betriebssystem [https://launchpad.net/gcc-arm-embedded herunterladen] und entpacken. Es gibt zwar auch Versionen in der Paketverwaltung mancher Linux-Distributionen aber die sind oft veraltet. Dafür bitte einen kurzen Pfad '''ohne Leerzeichen''' verwenden:
* Windows: z.B. C:\gcc-arm-embedded
* Linux: z.B. "/home/username/gcc-arm-embedded"
Den Pfad für später merken.
=== Make ===
* Linux: Meistens vorinstalliert. Unter Ubuntu im Paket "build-essential" enthalten.
* Windows: Hier können die MinGW/MSYS Basis Tools verwendet werden:
** Dazu [http://sourceforge.net/projects/mingw/files/latest/download hier] den MinGW Installer herunterladen und ausführen.
** Als Installation Directory am besten "C:\MinGW" beibehalten.
** So oft "Continue" anklicken, bis der "MinGW Installation Manager" erscheint und eine Liste installierbarer Pakete anzeigt.
** In der Liste das Paket "msys-base" mit der rechten Maustaste anklicken und "Mark for Installation" anklicken
** Im Menü "Installation"->"Apply Changes" anklicken, und mit "Apply" bestätigen.
** Nachdem der Vorgang abgeschlossen ist, das Programm beenden
=== Pfade setzen ===
'''Vor''' dem Starten von Eclipse müssen dem System die Pfade der Kommandozeilentools bekannt gemacht werden:
* Windows:
** Rechte Maustaste auf den Arbeitsplatz klicken, "Eigenschaften" -> "Erweiterte Systemeinstellungen" -> "Umgebungsvariablen" anklicken.
** Im '''unteren''' Listenfeld den Eintrag "Path" suchen, auf "Bearbeiten" klicken
** Ans Ende des Textes ein Semikolon hängen (falls nicht schon vorhanden), und durch zwei Semikola getrennt die Pfade zur J-Link Installation, zur GCC-ARM-Embedded -Installation (plus "\bin") und zur MSYS-Installation '''anhängen'''. Also zum Beispiel folgenden Text anhängen (Version anpassen) und alles mit OK bestätigen:
<code>;C:\gcc-arm-embedded\bin;C:\Program Files (x86)\SEGGER\JLink_V500e;C:\MinGW\msys\1.0\bin</code>
** In einem '''danach''' erst gestarteten cmd.exe Fenster den Befehl "JLink" eingeben. Es sollte die Lizenzvereinbarung von Segger erscheinen (diese bestätigen), und im Terminal wieder "exit" eingeben. Funktioniert dies nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "make" eingeben. Es sollte ein Meldung in der Art von "make: *** No targets specified and no makefile found. Stop." erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
* Linux:
** Mit einem Texteditor die (versteckte) Datei ".profile" im Home-Verzeichnis öffnen bzw. anlegen falls nicht vorhanden. Folgende Zeile '''anhägen''' (Pfad anpassen):
<code>export PATH=$PATH:/home/username/gcc-arm-embedded/bin</code>
** Den Benutzer ab- und wieder anmelden
** In einem Terminal-Fenster "JLinkExe" eingeben. Es sollte sich die JLink-Software mit "SEGGER J-Link Commander V5.00c ('?' for help)" melden. Diese wieder mit "exit" beenden. Falls das nicht funktioniert, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
Die Umgebungsvariable muss nach jedem Update der JLink-Software neu gesetzt werden, da der Pfad die Versionsnummer enthält.
=== Eclipse ===
* Da Eclipse auf Java basiert, muss dies zuerst installiert werden:
** Windows: Den [http://www.java.com/de/download/ Installer herunterladen] und laufen lassen.
** Linux: Je nach Distribution unterschiedlich, für Ubuntu [http://wiki.ubuntuusers.de/Java/Installation/Oracle_Java/Java_8#Installation siehe hier]
* Die aktuelle Version von "Eclipse IDE for C/C++ Developers" [http://www.eclipse.org/downloads/ hier herunterladen]. Unter Linux ist eclipse zwar auch oft in der Paketverwaltung enthalten, diese Version ist aber meist stark veraltet. Das heruntergeladene Archiv muss nur in einen beliebigen Ordner entpackt werden und die enthaltene Programmdatei (Linux: "eclipse", Windows: "eclipse.exe") gestartet werden.
* Den beim ersten Start erscheinenden "Welcome" Tab schließen.
* Im Menü "Help"->"Install new software" anwählen, unter "Work With" die URL <nowiki>"http://gnuarmeclipse.sourceforge.net/updates"</nowiki> eingeben, Enter klicken, den in der Liste erscheinenden Eintrag "GNU ARM C/C++ Cross Development Tools" auswählen, und mit "Next" und "Finish" installieren. Die Sicherheitsabfrage über unsignierte Software bestätigen, und die Abfrage zum Neustart von Eclipse bestätigen. Die Installation dauert etwas, und funktioniert manchmal nicht wenn die Server überlastet sind. Dann einfach später noch einmal probieren.
* Nur Windows: Im Menü "Window"->"Preferences" anklicken, in der Baumstruktur des erscheinenden Fensters "Run"->"String Substitution" anwählen, die Zeile mit "jlink_path" auswählen, "Edit" anklicken, und unter "Value" den Pfad zur JLink-Installation, also zB. "C:\Program Files (x86)\SEGGER\JLink_V500e" eintragen. Alles mit OK schließen.
* In der Toolbar den Eintrag "Make the C/C++ Packs perspective visible" anklicken, und das Symbol mit den gelben Pfeilen ("Update the package definitions from all repositories") anklicken. Dieser Vorgang dauert einige Minuten.
* In der erscheinenden Baumstruktur im Tab "Packs" unter dem Punkt "Keil" die Mikrocontroller auswählen (Mehrfachauswahl mit der Strg-Taste möglich) für die man programmieren möchte (zB. "STM32F4xx_DFP"), und mit der rechten Maustaste und Klick auf "Install" installieren. Auch dies dauert etwas, der Fortschritt des Vorgangs wird etwas versteckt rechts unten im Fenster angezeigt.
* Danach wieder mit Klick auf den "C/C++" Button oben rechts in die C/C++ Ansicht wechseln.

=== Standard Peripheral Library vorbereiten ===
Um auf die Hardware-Register direkt zuzugreifen oder die Treiberfunktionen von ST zu verwenden, sowie für den Startup-Code & Linkerscript, wird die Library von ST benötigt.
* Zum Herunterladen die Produktseite des Mikrocontrollers aufrufen (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für STM32F407VG), "Design Resources" anklicken, unter dem Punkt "Related Tools and Software" den Eintrag im Stil von "STM32F4 DSP and standard peripherals library" finden (zB [http://www.st.com/web/en/catalog/tools/PF257901 hier] für STM32F4). Ganz unten findet sich der "Download" Button.
Leider ist das Archiv nicht gut strukturiert. Daher müssen die entsprechenden Dateien herausgesucht werden:
* Im enthaltenen Verzeichnis "Project/*** Templates" nach Dateien suchen, die auf *.ld enden und die herauskopieren, deren Name zum verwendeten Mikrocontroller passt, also z.B. "STM32F417IG_FLASH.ld" für den STM32F4. Diese ist das Linkerscript und wird später für jedes Projekt benötigt. Zur Sicherheit sollte diese Datei einmal im Texteditor geöffnet und auf Fehler überprüft werden (ST ist bekannt dafür hier Fehler zu machen):
** Die Speicher-Größen-Angaben der folgenden Zeilen sollten zum Datasheet passen (ggf. anpassen):
<pre>MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
}</pre>
** Die Angabe der Adresse der Initialen Stack-Adresse sieht oft so aus:
<pre>_estack = 0x2001FFFF; /* end of RAM */</pre>
**Dies ist '''falsch''' (ST weiß selber nicht wie der Cortex-M funktioniert). Die angegebene Adresse sollte Anfangsadresse des RAM's (immer 0x20000000) plus RAM-Größe (z.B. beim STM32F407 0x20000 Bytes) sein, also z.B. 0x20020000 für den STM32F407:
<pre>_estack = 0x20020000; /* end of RAM */</pre>
** Ist dies falsch, kann es später zu schwer auffindbaren Problemen im Zusammenhang mit z.B. Floatingpoint-Funktionsargumenten kommen.
* Im Archiv nach Dateien suchen, deren Namen mit "startup_stm32" beginnt. Eine der Dateien heraussuchen, deren Name zum Mikrocontroller passt, '''und''' deren enthaltendes Verzeichnis den Namen TrueSTUDIO trägt, also zB. "Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f40_41xxx.s". Diese Datei herauskopieren, sie ist der Startup-Code und wird später für jedes Projekt benötigt. Dabei die Dateiendung von ".s" auf ".S" ändern, denn sonst erkennt eclipse sie nicht.
* Im Verzeichnis "Project/*** Templates" die Datei "stm32f***_conf.h" herauskopieren. Diese wird für Einstellungen in der Treiber-Library benötigt.
* Alles außer dem Verzeichnis "Libraries" löschen.
* Im Verzeichnis "Libraries" (rekursiv) nach Dateien & Ordnern suchen, die "example" oder "template" im Namen tragen und alle löschen.
* Die Unterverzeichnisse "Documentation", "Lib", "RTOS", "SVD" löschen. Die Lizenz und Release Notes-Dateien stören zwar nicht, können aber auch gelöscht werden. Im Endeffekt werden nur die .c und .h Dateien benötigt. Die DSP_Lib kann auch gelöscht werden, wenn keine DSP-Funktionen benötigt werden (existiert onehin nur für Cortex-M4 Controller).
* Leider enthält die Library für alle STM32F4 die Treiber für sowohl den FMC als auch den FSMC, obwohl beide nicht in allen Varianten vorhanden sind. Diese Treiber verursachen Compilerfehler, wenn für den falschen Controller kompiliert. Daher muss die Datei "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fmc.c" gelöscht werden, wenn kein FMC vorhanden ist (wie beim STM32F40x), bzw. die "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fsmc.c" wenn kein FSMC vorhanden ist (wie beim STM32F42x).
* Danach sollte nur noch so eine Struktur übrig bleigen:
<pre>./STM32F4xx_StdPeriph_Driver
./STM32F4xx_StdPeriph_Driver/src - Hier liegt der Quellcode für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_wwdg.c
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_usart.c
...
./STM32F4xx_StdPeriph_Driver/inc - Hier liegen die Includes für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_wwdg.h
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_usart.h
...
./CMSIS
./CMSIS/Include - Hier liegen die Includes für den Prozessorkern (Cortex-M*)
./CMSIS/Include/core_sc300.h
./CMSIS/Include/core_sc000.h
...
./CMSIS/DSP_Lib/Source/TransformFunctions - Hier liegt die DSP-Library (optional)
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q31.c
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q15.c
...
./CMSIS/Device/ST/STM32F4xx/Include
./CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h - Dies ist die Include-Datei für das Clock Setup
./CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h - Dies ist die zentrale Include-Datei für die Register-Definitionen</pre>

* Soll die Standard Peripheral Library nicht genutzt werden, sondern nur direkt die Register-Definitionen, werden nur die letzten beiden Dateien benötigt sowie die im Verzeichnis CMSIS/Include.
* In der Datei "CMSIS/Device/ST/STM32***/Include/stm32f***.h" befindet sich ganz oben eine Präprozessor-Fallunterscheidung der Form
<syntaxhighlight lang="c">#if !defined (STM32F40_41xxx) && !defined (STM32F427_437xx) && !defined (STM32F429_439xx) && !defined (STM32F401xx) && !defined (STM32F411xE)
/* #define STM32F40_41xxx */ /*!< STM32F405RG, STM32F405VG, STM32F405ZG, STM32F415RG, STM32F415VG, STM32F415ZG,
STM32F407VG, STM32F407VE, STM32F407ZG, STM32F407ZE, STM32F407IG, STM32F407IE,
STM32F417VG, STM32F417VE, STM32F417ZG, STM32F417ZE, STM32F417IG and STM32F417IE Devices */

/* #define STM32F427_437xx */ /*!< STM32F427VG, STM32F427VI, STM32F427ZG, STM32F427ZI, STM32F427IG, STM32F427II,
STM32F437VG, STM32F437VI, STM32F437ZG, STM32F437ZI, STM32F437IG, STM32F437II Devices */

/* #define STM32F429_439xx */ /*!< STM32F429VG, STM32F429VI, STM32F429ZG, STM32F429ZI, STM32F429BG, STM32F429BI,
STM32F429NG, STM32F439NI, STM32F429IG, STM32F429II, STM32F439VG, STM32F439VI,
STM32F439ZG, STM32F439ZI, STM32F439BG, STM32F439BI, STM32F439NG, STM32F439NI,
STM32F439IG and STM32F439II Devices */

/* #define STM32F401xx */ /*!< STM32F401CB, STM32F401CC, STM32F401RB, STM32F401RC, STM32F401VB, STM32F401VC
STM32F401CD, STM32F401RD, STM32F401VD, STM32F401CExx, STM32F401RE and STM32F401VE Devices */

/* #define STM32F411xE */ /*!< STM32F411CD, STM32F411RD, STM32F411VD, STM32F411CE, STM32F411RE and STM32F411VE Devices */
#endif</syntaxhighlight>
Hier mithilfe des Kommentars das Präprozessor-Makro heraussuchen, das zum verwendeten Mikrocontroller passt, also z.B. "STM32F40_41xxx" für den STM32F407VG. Dieses kopieren und für später merken.

== Projekt erstellen ==
=== Clock-Konfiguration generieren ===
Zum Initialisieren des Takts wird eine spezielle Funktion benötigt, die je nach Art und Frequenz des Takts spezifisch erzeugt werden muss. ST bietet ein Tool, um diese Datei zu generieren:
* Auf der Produkt seite des Mikrocontrollers (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für den STM32F407VG) auf "Design Resources" klicken, und den Eintrag in der Art von "Clock configuration tool for STM32F40x/41x microcontrollers (AN3988)" finden.
* Die Datei herunterladen und mit MS Excel öffnen. Die gewünschte Clock-Konfiguration auswählen, und den Code generieren lassen. Die Datei zB unter dem Namen system_stm32f4xx.c speichern.
=== Eclipse Projekt konfigurieren ===
[[Datei:Eclipse STM32 Project.png|right|thumb|Fertiges Projekt in Eclipse geöffnet]]Neue Projekte werden über "File"->"New"->"Project..." angelegt.
* In der Baumstruktur "C/C++ -> C++ Project" auswählen. Im C++ Projekt kann man natürlich auch einfachen C Code schreiben, aber es ist die Möglichkeit für C++ offen gehalten.
* In der Baumstruktur "Empty Project" auswählen, und rechts "Cross ARM GCC". Es können zwar auch die einfacheren Vorlagen für spezifische Controller wie "STM32F4xx C/C++ Project" verwendet werden, dies ist aber weniger flexibel, weswegen hier ersteres erläutert wird.
* Als Namen bitte einen ohne Leerzeichen oder Sonderzeichen verwenden.
* Mit 2x "Next" und 1x "Finish" das Erstellen abschließen.
* Das zuvor gesicherte Linkerscript (mit der Endung .ld) in das Projektverzeichnis kopieren. Den Projektnamen links anklicken, rechts Maustaste, und "Refresh" (oder F5) drücken. Das Linker-Script sollte im Dateibaum erscheinen.
* Im Projekt müssen zunächst einige Einstellungen vorgenommen werden. Dazu mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
** Im erscheinenden Fenster, im DropDown Menü oben "[All Configurations]" auswählen
** Nur Linux: In der Baumstruktur "C/C++ Build" auswählen, den Reiter "Behaviour" öffnen, den Haken bei "Enable Parallel Build" setzen. Dies beschleunigt die Kompilierung, funktioniert aber nicht unter Windows (beim Kopieren des Projekts beachten).
** In der Baumstruktur "C/C++ Build" -> "Settings" anwählen. Das Öffnen dauert in aktuellen Versionen etwas, vermutlich ein Bug.
*** In der 2. Baumstruktur "Target processor" auswählen.
**** Unter "ARM family" den gewünschten Prozessor auswählen, also z.B. "cortex-m4" für STMF4 oder "cortex-m3" für STM32F1.
**** Nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Unter Float ABI "FP instructions (hard)" auswählen
***** Unter "FPU Type" "fpv4-sp-d16 " auswählen. Siehe [https://launchpadlibrarian.net/209775724/readme.txt hier in der Tabelle] für die möglichen Werte der verschiedenen Prozessoren.
*** Es ist zu empfehlen, LTO beim Kompilieren im Release-Modus zu aktivieren. Dies resultiert in kleineren und schnelleren Binaries, erschwert aber das Debugging mit GDB sehr:
**** Oben die Configuration "Release" auswählen
**** In der 2. Baumstruktur "Optimization" auswählen
**** "Link-time optimizer (-flto)" aktivieren
**** Oben wieder "[All configurations]" anklicken
*** In der 2. Baumstruktur "Cross ARM C++ Compiler -> Optimization" anklicken
**** Rechts "Do not use exceptions (-fno-exceptions) anwählen
**** Rechts "Do not use RTTO (-fno-rtti)" anwählen
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "General" auswählen
**** In der Toolbar auf "Add" klicken, auf "Workspace" klicken, und das soeben in das Projekt kopierte Linkerscript auswählen.
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "Miscellaneous" auswählen
**** Den Haken bei "Use newlib-nano (--specs=nano.specs)" setzen.
**** Optional, nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Den Haken bei "Use float with with nano printf (-u _printf_float)" setzen. Dies ermöglicht die Nutzung von "%f" bei "printf", verbraucht aber automatisch eine Menge Flash+RAM und benötigt die Syscalls für malloc (s.u.). Daher ist ggf. zu empfehlen, dies nur in der Debug-Konfiguration zu aktivieren. Dazu in der Dropbown-Box oben vor aktivieren dieser Einstellung auf "Debug" klicken, und danach wieder auf "[All Configurations]".
*** Im Reiter "Devices" in der Baumstruktur den verwendeten Mikrocontroller, wie zB "STM32F407VG" auswählen.
** In der linken Baumstruktur "C/C++ General"->"Paths and Symbols" auswählen
*** Oben im Drop-Down-Menü "Debug" anklicken
*** Im Reiter "Symbols" rechts auf "Add" klicken und dadurch nacheinander folgende Symbole definieren. Dabei immer beide Häkchen setzen!
**** Name "HSE_VALUE" Value=Takt des Quarzes, z.B. 8000000
**** Name "USE_STDPERIPH_DRIVER" Value leerlassen
**** Name "__FPU_PRESENT" Value=1
**** Das zuvor gemerkte Präprozessor-Makro aus der "stm32f**.h" (zB. STM32F40_41xxx) Value leerlassen
**** Name "ARM_MATH_CM4", "ARM_MATH_CM3", "ARM_MATH_CM0", oder "ARM_MATH_CM0PLUS" je nachdem ob für den Cortex-M4, -M3, -M0, oder -M0+ kompiliert wird; Value leerlassen
** Das Fenster mit OK schließen.
Nun ist der Compiler an sich richtig konfiguriert. Allerdings fehlt noch die Library von ST:
* Die zuvor vorbereitete Standard Peripheral Library (d.h. das Verzeichnis "Libraries") in das Projektverzeichnis kopieren. Dies ist leider die einzig sinnvolle & einfache Möglichkeit.
* Den zuvor gesicherten Startup-Code, also zB. "startup_stm32f40_41xxx.S" in das Projektverzeichnis kopieren
* Die zuvor gesicherte Datei "stm32f***_conf.h" in das Projektverzeichnis kopieren
* Die zuvor generierte Datei "system_stm32f**" mit der Clock-Konfiguration in das Projektverzeichnis kopieren
Jetzt müssen dem Compiler noch die Pfade der Header-Dateien der Library mitgeteilt werden:
* Mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
* Links in der Baumstruktur "C/C++ General" -> "Paths and Symbols" anklicken, und den Reiter "Includes" auswählen.
* Oben im Drop-Down-Menü "Debug" auswählen.
* Mit "Add" nacheinander folgende Pfade hinzufügen. Dazu jeweils "Add to all languages" sowie "Add to all configurations" einschalten, und den "Workspace..." Button verwenden.
** "Libraries/CMSIS/Device/ST/STM32F***/Include"
** "Libraries/CMSIS/Include"
** "Libraries/STM32F**_StdPeriph_Driver/inc"
** Den Pfad, in dem sich die "stm32f***_conf.h" befindet, also typischerweise das Projektverzeichnis selber.
* Mit OK das Fenster schließen. Danach wird Eclipse die C/C++ Analyse laufen lassen. Dies kann etwas dauern und die weitere Bedienung währenddessen verlangsamen. Der Fortschritt ist unten rechts im Fenster zu sehen.

=== Linkerscript anpassen ===
Noch einmal das soeben hineinkopierte Linkerscript (mit der Endung .ld) öffnen. Die Zeile mit "_Min_Heap_Size" gibt die Größe des Heaps, d.h. des für malloc() zur Verfügung stehenden Speichers an. Wird malloc() nicht verwendet, kann dies auf 0 gesetzt werden. Soll printf() verwendet werden, ist zu empfehlen hier mindestens 2048 anzugeben, da printf sonst schnell keinen Speicher mehr hat und es zu komischem Verhalten kommt:
<pre>_Min_Heap_Size = 2048; /* required amount of heap */</pre>

=== Optional: Syscalls implementieren ===
Soll im Code printf() und/oder malloc() verwendet werden können, müssen die [https://sourceware.org/newlib/libc.html#Syscalls Syscalls der C-Library] implementiert werden. Dazu ist es empfehlenswert, [[Media:Newlib cortexm syscalls.c|diesen Beispielcode]] zu verwenden und in das Projektverzeichnis zu kopieren. Er gibt per printf() ausgebenen Texte seriell per SWO aus. Dies ist ein Extra-Pin im SWD-Debug-Interface (bei JTAG nicht verfügbar), der vom JLink eingelesen und über die JLink-Software an Eclipse geschickt wird. Der Code kann auch angepasst werden um den Text zB per UART auszugeben.

== Code schreiben und kompilieren ==
Dem Projekt kann jetzt eine eigene Quellcodedatei hinzugefügt werden. Dazu mit der rechten Maustaste auf den Projektnamen klicken, "New"->"Source file" auswählen. Die Datei z.B. "main.c" (für C) oder "main.cpp" (für C++) nennen. [[Media:Stm32f4 eclipse example.c|Hier]] kann ein einfacher Beispielcode für den STM32F407 heruntergeladen werden (funktioniert sowohl mit C als auch C++), der eine LED am Pin PD15 blinken lässt (blaue LED auf dem [http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF252419 STM32F4 Discovery Board]). Der Code braucht auf jeden Fall eine "main()"-Funktion, sowie im Falle von C++ eine Funktion namens "__cxa_pure_virtual":
<syntaxhighlight lang="cpp">extern "C" void __cxa_pure_virtual () {
// This is an error callback for C++
__disable_irq ();
while (1) {
// Cause debugger breakpoint
asm volatile ("bkpt");
}
}</syntaxhighlight>
Wird die oben verlinkte syscalls.c Datei nicht eingebunden, wird außerdem auch noch eine _exit Funktion benötigt:
<syntaxhighlight lang="cpp">

#ifdef __cplusplus
extern "C"
void _exit(int) {
#else
void _exit (int status) {
((void) status);
#endif
// Stop controller in case of fatal error
__disable_irq ();
while (1) {
asm volatile ("bkpt");
}
__builtin_unreachable ();
}
</syntaxhighlight>
Dies sind Callbacks zur Fehlerbehandlung. Durch Überschreiben durch simples Blockieren des Controllers wird das Einbinden der komplexen Fehlerbehandlung der Standardbibliothek verhindert.
Danach kann der Code zum ersten Mal kompiliert werden. Dazu das Hammer-Symbol "Build" in der Toolbar benutzen. Fehlermeldungen sollten dem "Console" Fenster entnommen werden, da das "Problems" Fenster nicht immer korrekt funktioniert. Die erzeugten Dateien landen im Unterordner "Debug" bzw. "Release", je nachdem welche Konfiguration gewählt ist. Die generierte Datei mit der Endung .elf (zB Debug/MeinProjekt.elf) enthält den produzierten Code sowie alle Debug-Informationen. Es wird auch eine .hex Datei angelegt, die das erzeugte Flash-Image enthält.

== Debugging ==
=== Debug Configuration anlegen ===
Um den Code zu flashen und debuggen, wird eine Debug Configuration benötigt. Dazu im Menü auf "Run"->"Debug Configurations" klicken. Sollen sowohl Debug- als auch Release- Versionen so geflasht/debuggt werden, müssen mehrere Debug Configurations angelegt werden. Dazu ist es am einfachsten, eine anzulegen und mehrfach zu kopieren.
* Im erscheinenden Fenster in der Liste auf "GDB SEGGER J-Link Debugging" klicken, und oben auf das Symbol "New launch configuration".
* Im Reiter "Main", unter "C/C++ Application" den Pfad zum kompilierten ELF-File angeben, also zB "Debug/ProjektName.elf".
* Im Reiter "Startup" sollte "Enable SWO" aktiviert, und daneben die CPU-Frequenz in Hz angegeben werden (zB 168000000 für den STM32F4).
* Im Reiter "Common" kann in der Liste "Display in favorites menu" ein Haken bei "Debug" gesetzt werden. Dadurch ist diese Debug Configuration schneller über das Käfer-Symbol in der Toolbar im Hauptmenü zugänglich.
* Über "Apply" und "Close" das Fenster schließen.
=== Debug Session starten ===
[[Datei:Eclipse STM32 Debugging.png|right|thumb|Laufende Debug-Session]]* Auf das kleine schwarze Dreieck neben dem Käfer-Symbol ("Debug") in der Toolbar klicken, und die soeben angelegte Debug-Configuration auswählen. Eclipse wechselt nun in die Debug-Perspektive. Nach Beendigung der Debug-Session kann über den "C/C++"-Knopf oben rechts wieder in die normale Ansicht gewechselt werden.
* Es ist zu empfehlen die einzelnen Fenster der Ansicht so zu verschieben, dass mehr Code gleichzeitig sichtbar ist.
* Standardmäßig legt eclipse automatisch einen Breakpoint zu Beginn der "main" Funktion an.
* Über die Knöpfe "Resume", "Break", "Terminate" kann die Ausführung kontrolliert werden. Durch Doppelklick links neben eine Zeile werden Breakpoints gesetzt.
* Das ARM Plugin ermöglicht das Betrachten von Peripherie-Registern mit Trennung der einzelnen Felder. Dazu im Fenster "Peripherals" die Peripherie-Einheiten, deren Inhalt man betrachten möchte, auswählen. Im "Memory" Fenster werden dann die Register angezeigt. Die Ansicht wird immer nach jedem Ausführungsschritt aktualisiert, nicht immer sofort. Im Zweifelsfall also eine Zeile weiter laufen lassen, um die Ansicht zu aktualisieren.
* Ausgaben per "printf" erscheinen automatisch unten in der Konsole.

== Siehe auch ==
* [[STM32#Tutorials_f.C3.BCr_diverse_Tool-Kombinationen|Weitere Tutorials für STM32-IDE's]]
* [[ARM_GCC|Verwendung des GCC für Bare-Metal ARM]]
* [http://diller-technologies.de/stm32_wide.html Tutorial zur STM32 Programmierung]

STM32 Eclipse JLink Linux/Windows

2015-06-28T12:13:35Z

Kichi: /* Einführung */

== Einführung ==
Da viele Tutorials zur Verwendung von Eclipse mit [[STM32]] auf relativ alten Tools aufsetzen, hier eine Anleitung mit aktuellem (2015) Stand. Hier wird die Programmierung von STM32 (ähnlich auch auf andere Cortex-M anwendbar) mit der Tool-Kombination [http://www.eclipse.org/ Eclipse] + [https://www.segger.com/jlink-debug-probes.html Segger JLink] + [https://launchpad.net/gcc-arm-embedded GCC-ARM-Embedded] + GDB erläutert für Linux und Windows. Die Tools gibt es auch für Mac OS, entsprechende Hinweise zur Benutzung fehlen hier noch. Der J-Link ist zwar relativ teuer (ca. 50€ für Privatpersonen), dafür aber schnell und stabil, kennt (fast?) alle ARM's und funktioniert plattformübergreifend direkt mit der Software vom Hersteller. Diese Kombination ermöglicht:
* Nutzung der komfortablen und mächtigen Entwicklungsumgebung Eclipse, inkl. Code-Vervollständigung und vielen Plugins wie zB. für Versionsverwaltung
* Automatische Generierung von makefiles und Aufruf des Compilers, kein manuelles Bearbeiten erforderlich
* Graphisches und schnelles Flashen und Debugging über JLink und GDB
* Graphische Anzeige von Registerinhalten beim Debugging
* Optional: Ausgabe von Texten per printf direkt nach Eclipse
* Projekte können zwischen Betriebssystemen ausgetauscht werden, Workflow generell fast identisch
* Voller Support für FPU der Cortex-M4, voller Support für C++, kein Codesize-Limit
* Es werden generische C/C++ Projekte angelegt; dies ist zwar etwas komplizierter, bietet aber später mehr Einstellungsmöglichkeiten
* Die Software ist auch für kommerzielle Nutzung komplett gratis und bis auf JLink auch OpenSource. Nur der JLink-Adapter selber ist für kommerzielle Nutzung teurer (aber das ist er bei Verwendung mit anderen IDE's natürlich auch).
* Da die normale und keine angepasste Eclipse-Version verwendet wird, können in der selben Eclipse-Instanz auch Projekte für völlig andere Plattformen und Sprachen benutzt werden, wie z.B. C/C++ für den PC, Java, ruby usw.
Da Eclipse eine sehr vielseitige Entwicklungsumgebung ist, sind einige Schritte erforderlich, um das Projekt auf die speziellen Anforderungen der Embedded-Entwicklung anzupassen. Diese sind im Folgenden erläutert.

Zusätzlich dazu ist es sehr empfehlenswert bei der Einrichtung immer wieder einen Blick auf die Anleitungen und Beschreibungen auf der [http://gnuarmeclipse.livius.net GNU ARM Eclipse Homepage] zu werfen, da die Vorgehensweise dort gut beschrieben ist und sich auch gelegentlich ändert.

== Installation ==
=== JLink ===
Zunächst die aktuelle Version von der [https://www.segger.com/jlink-software.html JLink Software] herunterladen und installieren. Da es hier regelmäßig neue Versionen gibt, ist es empfehlenswert sich für die [https://www.segger.com/notification/subscribe.php?prodid=7 E-Mail-Benachrichtigung] für neue Versionen einzutragen. Das Installationsverzeichnis für später merken.
=== GCC-ARM-Embedded ===
Die aktuelle Version für das jeweilige Betriebssystem [https://launchpad.net/gcc-arm-embedded herunterladen] und entpacken. Es gibt zwar auch Versionen in der Paketverwaltung mancher Linux-Distributionen aber die sind oft veraltet. Dafür bitte einen kurzen Pfad '''ohne Leerzeichen''' verwenden:
* Windows: z.B. C:\gcc-arm-embedded
* Linux: z.B. "/home/username/gcc-arm-embedded"
Den Pfad für später merken.
=== Make ===
* Linux: Meistens vorinstalliert. Unter Ubuntu im Paket "build-essential" enthalten.
* Windows: Hier können die MinGW/MSYS Basis Tools verwendet werden:
** Dazu [http://sourceforge.net/projects/mingw/files/latest/download hier] den MinGW Installer herunterladen und ausführen.
** Als Installation Directory am besten "C:\MinGW" beibehalten.
** So oft "Continue" anklicken, bis der "MinGW Installation Manager" erscheint und eine Liste installierbarer Pakete anzeigt.
** In der Liste das Paket "msys-base" mit der rechten Maustaste anklicken und "Mark for Installation" anklicken
** Im Menü "Installation"->"Apply Changes" anklicken, und mit "Apply" bestätigen.
** Nachdem der Vorgang abgeschlossen ist, das Programm beenden
=== Pfade setzen ===
'''Vor''' dem Starten von Eclipse müssen dem System die Pfade der Kommandozeilentools bekannt gemacht werden:
* Windows:
** Rechte Maustaste auf den Arbeitsplatz klicken, "Eigenschaften" -> "Erweiterte Systemeinstellungen" -> "Umgebungsvariablen" anklicken.
** Im '''unteren''' Listenfeld den Eintrag "Path" suchen, auf "Bearbeiten" klicken
** Ans Ende des Textes ein Semikolon hängen (falls nicht schon vorhanden), und durch zwei Semikola getrennt die Pfade zur J-Link Installation, zur GCC-ARM-Embedded -Installation (plus "\bin") und zur MSYS-Installation '''anhängen'''. Also zum Beispiel folgenden Text anhängen (Version anpassen) und alles mit OK bestätigen:
<code>;C:\gcc-arm-embedded\bin;C:\Program Files (x86)\SEGGER\JLink_V500e;C:\MinGW\msys\1.0\bin</code>
** In einem '''danach''' erst gestarteten cmd.exe Fenster den Befehl "JLink" eingeben. Es sollte die Lizenzvereinbarung von Segger erscheinen (diese bestätigen), und im Terminal wieder "exit" eingeben. Funktioniert dies nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "make" eingeben. Es sollte ein Meldung in der Art von "make: *** No targets specified and no makefile found. Stop." erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
* Linux:
** Mit einem Texteditor die (versteckte) Datei ".profile" im Home-Verzeichnis öffnen bzw. anlegen falls nicht vorhanden. Folgende Zeile '''anhägen''' (Pfad anpassen):
<code>export PATH=$PATH:/home/username/gcc-arm-embedded/bin</code>
** Den Benutzer ab- und wieder anmelden
** In einem Terminal-Fenster "JLinkExe" eingeben. Es sollte sich die JLink-Software mit "SEGGER J-Link Commander V5.00c ('?' for help)" melden. Diese wieder mit "exit" beenden. Falls das nicht funktioniert, wurde die Umgebungsvariable falsch gesetzt.
** Im selben Fenster "arm-none-eabi-gcc" eingeben. Es sollte eine Meldung im Stil von "arm-none-eabi-gcc: fatal error: no input files" erscheinen. Falls nicht, wurde die Umgebungsvariable falsch gesetzt.
Die Umgebungsvariable muss nach jedem Update der JLink-Software neu gesetzt werden, da der Pfad die Versionsnummer enthält.
=== Eclipse ===
* Da Eclipse auf Java basiert, muss dies zuerst installiert werden:
** Windows: Den [http://www.java.com/de/download/ Installer herunterladen] und laufen lassen.
** Linux: Je nach Distribution unterschiedlich, für Ubuntu [http://wiki.ubuntuusers.de/Java/Installation/Oracle_Java/Java_8#Installation siehe hier]
* Die aktuelle Version von "Eclipse IDE for C/C++ Developers" [http://www.eclipse.org/downloads/ hier herunterladen]. Unter Linux ist eclipse zwar auch oft in der Paketverwaltung enthalten, diese Version ist aber meist stark veraltet. Das heruntergeladene Archiv muss nur in einen beliebigen Ordner entpackt werden und die enthaltene Programmdatei (Linux: "eclipse", Windows: "eclipse.exe") gestartet werden.
* Den beim ersten Start erscheinenden "Welcome" Tab schließen.
* Im Menü "Help"->"Install new software" anwählen, unter "Work With" die URL <nowiki>"http://gnuarmeclipse.sourceforge.net/updates"</nowiki> eingeben, Enter klicken, den in der Liste erscheinenden Eintrag "GNU ARM C/C++ Cross Development Tools" auswählen, und mit "Next" und "Finish" installieren. Die Sicherheitsabfrage über unsignierte Software bestätigen, und die Abfrage zum Neustart von Eclipse bestätigen. Die Installation dauert etwas, und funktioniert manchmal nicht wenn die Server überlastet sind. Dann einfach später noch einmal probieren.
* Nur Windows: Im Menü "Window"->"Preferences" anklicken, in der Baumstruktur des erscheinenden Fensters "Run"->"String Substitution" anwählen, die Zeile mit "jlink_path" auswählen, "Edit" anklicken, und unter "Value" den Pfad zur JLink-Installation, also zB. "C:\Program Files (x86)\SEGGER\JLink_V500e" eintragen. Alles mit OK schließen.
* In der Toolbar den Eintrag "Make the C/C++ Packs perspective visible" anklicken, und das Symbol mit den gelben Pfeilen ("Update the package definitions from all repositories") anklicken. Dieser Vorgang dauert einige Minuten.
* In der erscheinenden Baumstruktur im Tab "Packs" unter dem Punkt "Keil" die Mikrocontroller auswählen (Mehrfachauswahl mit der Strg-Taste möglich) für die man programmieren möchte (zB. "STM32F4xx_DFP"), und mit der rechten Maustaste und Klick auf "Install" installieren. Auch dies dauert etwas, der Fortschritt des Vorgangs wird etwas versteckt rechts unten im Fenster angezeigt.
* Danach wieder mit Klick auf den "C/C++" Button oben rechts in die C/C++ Ansicht wechseln.

=== Standard Peripheral Library vorbereiten ===
Um auf die Hardware-Register direkt zuzugreifen oder die Treiberfunktionen von ST zu verwenden, sowie für den Startup-Code & Linkerscript, wird die Library von ST benötigt.
* Zum Herunterladen die Produktseite des Mikrocontrollers aufrufen (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für STM32F407VG), "Design Resources" anklicken, unter dem Punkt "Related Tools and Software" den Eintrag im Stil von "STM32F4 DSP and standard peripherals library" finden (zB [http://www.st.com/web/en/catalog/tools/PF257901 hier] für STM32F4). Ganz unten findet sich der "Download" Button.
Leider ist das Archiv nicht gut strukturiert. Daher müssen die entsprechenden Dateien herausgesucht werden:
* Im enthaltenen Verzeichnis "Project/*** Templates" nach Dateien suchen, die auf *.ld enden und die herauskopieren, deren Name zum verwendeten Mikrocontroller passt, also z.B. "STM32F417IG_FLASH.ld" für den STM32F4. Diese ist das Linkerscript und wird später für jedes Projekt benötigt. Zur Sicherheit sollte diese Datei einmal im Texteditor geöffnet und auf Fehler überprüft werden (ST ist bekannt dafür hier Fehler zu machen):
** Die Speicher-Größen-Angaben der folgenden Zeilen sollten zum Datasheet passen (ggf. anpassen):
<pre>MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 1024K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 128K
CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K
}</pre>
** Die Angabe der Adresse der Initialen Stack-Adresse sieht oft so aus:
<pre>_estack = 0x2001FFFF; /* end of RAM */</pre>
**Dies ist '''falsch''' (ST weiß selber nicht wie der Cortex-M funktioniert). Die angegebene Adresse sollte Anfangsadresse des RAM's (immer 0x20000000) plus RAM-Größe (z.B. beim STM32F407 0x20000 Bytes) sein, also z.B. 0x20020000 für den STM32F407:
<pre>_estack = 0x20020000; /* end of RAM */</pre>
** Ist dies falsch, kann es später zu schwer auffindbaren Problemen im Zusammenhang mit z.B. Floatingpoint-Funktionsargumenten kommen.
* Im Archiv nach Dateien suchen, deren Namen mit "startup_stm32" beginnt. Eine der Dateien heraussuchen, deren Name zum Mikrocontroller passt, '''und''' deren enthaltendes Verzeichnis den Namen TrueSTUDIO trägt, also zB. "Libraries/CMSIS/Device/ST/STM32F4xx/Source/Templates/TrueSTUDIO/startup_stm32f40_41xxx.s". Diese Datei herauskopieren, sie ist der Startup-Code und wird später für jedes Projekt benötigt. Dabei die Dateiendung von ".s" auf ".S" ändern, denn sonst erkennt eclipse sie nicht.
* Im Verzeichnis "Project/*** Templates" die Datei "stm32f***_conf.h" herauskopieren. Diese wird für Einstellungen in der Treiber-Library benötigt.
* Alles außer dem Verzeichnis "Libraries" löschen.
* Im Verzeichnis "Libraries" (rekursiv) nach Dateien & Ordnern suchen, die "example" oder "template" im Namen tragen und alle löschen.
* Die Unterverzeichnisse "Documentation", "Lib", "RTOS", "SVD" löschen. Die Lizenz und Release Notes-Dateien stören zwar nicht, können aber auch gelöscht werden. Im Endeffekt werden nur die .c und .h Dateien benötigt. Die DSP_Lib kann auch gelöscht werden, wenn keine DSP-Funktionen benötigt werden (existiert onehin nur für Cortex-M4 Controller).
* Leider enthält die Library für alle STM32F4 die Treiber für sowohl den FMC als auch den FSMC, obwohl beide nicht in allen Varianten vorhanden sind. Diese Treiber verursachen Compilerfehler, wenn für den falschen Controller kompiliert. Daher muss die Datei "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fmc.c" gelöscht werden, wenn kein FMC vorhanden ist (wie beim STM32F40x), bzw. die "STM32F4xx_StdPeriph_Driver/src/stm32f4xx_fsmc.c" wenn kein FSMC vorhanden ist (wie beim STM32F42x).
* Danach sollte nur noch so eine Struktur übrig bleigen:
<pre>./STM32F4xx_StdPeriph_Driver
./STM32F4xx_StdPeriph_Driver/src - Hier liegt der Quellcode für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_wwdg.c
./STM32F4xx_StdPeriph_Driver/src/stm32f4xx_usart.c
...
./STM32F4xx_StdPeriph_Driver/inc - Hier liegen die Includes für die Peripherie-Treiber
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_wwdg.h
./STM32F4xx_StdPeriph_Driver/inc/stm32f4xx_usart.h
...
./CMSIS
./CMSIS/Include - Hier liegen die Includes für den Prozessorkern (Cortex-M*)
./CMSIS/Include/core_sc300.h
./CMSIS/Include/core_sc000.h
...
./CMSIS/DSP_Lib/Source/TransformFunctions - Hier liegt die DSP-Library (optional)
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q31.c
./CMSIS/DSP_Lib/Source/TransformFunctions/arm_rfft_q15.c
...
./CMSIS/Device/ST/STM32F4xx/Include
./CMSIS/Device/ST/STM32F4xx/Include/system_stm32f4xx.h - Dies ist die Include-Datei für das Clock Setup
./CMSIS/Device/ST/STM32F4xx/Include/stm32f4xx.h - Dies ist die zentrale Include-Datei für die Register-Definitionen</pre>

* Soll die Standard Peripheral Library nicht genutzt werden, sondern nur direkt die Register-Definitionen, werden nur die letzten beiden Dateien benötigt sowie die im Verzeichnis CMSIS/Include.
* In der Datei "CMSIS/Device/ST/STM32***/Include/stm32f***.h" befindet sich ganz oben eine Präprozessor-Fallunterscheidung der Form
<syntaxhighlight lang="c">#if !defined (STM32F40_41xxx) && !defined (STM32F427_437xx) && !defined (STM32F429_439xx) && !defined (STM32F401xx) && !defined (STM32F411xE)
/* #define STM32F40_41xxx */ /*!< STM32F405RG, STM32F405VG, STM32F405ZG, STM32F415RG, STM32F415VG, STM32F415ZG,
STM32F407VG, STM32F407VE, STM32F407ZG, STM32F407ZE, STM32F407IG, STM32F407IE,
STM32F417VG, STM32F417VE, STM32F417ZG, STM32F417ZE, STM32F417IG and STM32F417IE Devices */

/* #define STM32F427_437xx */ /*!< STM32F427VG, STM32F427VI, STM32F427ZG, STM32F427ZI, STM32F427IG, STM32F427II,
STM32F437VG, STM32F437VI, STM32F437ZG, STM32F437ZI, STM32F437IG, STM32F437II Devices */

/* #define STM32F429_439xx */ /*!< STM32F429VG, STM32F429VI, STM32F429ZG, STM32F429ZI, STM32F429BG, STM32F429BI,
STM32F429NG, STM32F439NI, STM32F429IG, STM32F429II, STM32F439VG, STM32F439VI,
STM32F439ZG, STM32F439ZI, STM32F439BG, STM32F439BI, STM32F439NG, STM32F439NI,
STM32F439IG and STM32F439II Devices */

/* #define STM32F401xx */ /*!< STM32F401CB, STM32F401CC, STM32F401RB, STM32F401RC, STM32F401VB, STM32F401VC
STM32F401CD, STM32F401RD, STM32F401VD, STM32F401CExx, STM32F401RE and STM32F401VE Devices */

/* #define STM32F411xE */ /*!< STM32F411CD, STM32F411RD, STM32F411VD, STM32F411CE, STM32F411RE and STM32F411VE Devices */
#endif</syntaxhighlight>
Hier mithilfe des Kommentars das Präprozessor-Makro heraussuchen, das zum verwendeten Mikrocontroller passt, also z.B. "STM32F40_41xxx" für den STM32F407VG. Dieses kopieren und für später merken.

== Projekt erstellen ==
=== Clock-Konfiguration generieren ===
Zum Initialisieren des Takts wird eine spezielle Funktion benötigt, die je nach Art und Frequenz des Takts spezifisch erzeugt werden muss. ST bietet ein Tool, um diese Datei zu generieren:
* Auf der Produkt seite des Mikrocontrollers (zB [http://www.st.com/web/catalog/mmc/FM141/SC1169/SS1577/LN11/PF252140 hier] für den STM32F407VG) auf "Design Resources" klicken, und den Eintrag in der Art von "Clock configuration tool for STM32F40x/41x microcontrollers (AN3988)" finden.
* Die Datei herunterladen und mit MS Excel öffnen. Die gewünschte Clock-Konfiguration auswählen, und den Code generieren lassen. Die Datei zB unter dem Namen system_stm32f4xx.c speichern.
=== Eclipse Projekt konfigurieren ===
[[Datei:Eclipse STM32 Project.png|right|thumb|Fertiges Projekt in Eclipse geöffnet]]Neue Projekte werden über "File"->"New"->"Project..." angelegt.
* In der Baumstruktur "C/C++ -> C++ Project" auswählen. Im C++ Projekt kann man natürlich auch einfachen C Code schreiben, aber es ist die Möglichkeit für C++ offen gehalten.
* In der Baumstruktur "Empty Project" auswählen, und rechts "Cross ARM GCC". Es können zwar auch die einfacheren Vorlagen für spezifische Controller wie "STM32F4xx C/C++ Project" verwendet werden, dies ist aber weniger flexibel, weswegen hier ersteres erläutert wird.
* Als Namen bitte einen ohne Leerzeichen oder Sonderzeichen verwenden.
* Mit 2x "Next" und 1x "Finish" das Erstellen abschließen.
* Das zuvor gesicherte Linkerscript (mit der Endung .ld) in das Projektverzeichnis kopieren. Den Projektnamen links anklicken, rechts Maustaste, und "Refresh" (oder F5) drücken. Das Linker-Script sollte im Dateibaum erscheinen.
* Im Projekt müssen zunächst einige Einstellungen vorgenommen werden. Dazu mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
** Im erscheinenden Fenster, im DropDown Menü oben "[All Configurations]" auswählen
** Nur Linux: In der Baumstruktur "C/C++ Build" auswählen, den Reiter "Behaviour" öffnen, den Haken bei "Enable Parallel Build" setzen. Dies beschleunigt die Kompilierung, funktioniert aber nicht unter Windows (beim Kopieren des Projekts beachten).
** In der Baumstruktur "C/C++ Build" -> "Settings" anwählen. Das Öffnen dauert in aktuellen Versionen etwas, vermutlich ein Bug.
*** In der 2. Baumstruktur "Target processor" auswählen.
**** Unter "ARM family" den gewünschten Prozessor auswählen, also z.B. "cortex-m4" für STMF4 oder "cortex-m3" für STM32F1.
**** Nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Unter Float ABI "FP instructions (hard)" auswählen
***** Unter "FPU Type" "fpv4-sp-d16 " auswählen. Siehe [https://launchpadlibrarian.net/209775724/readme.txt hier in der Tabelle] für die möglichen Werte der verschiedenen Prozessoren.
*** Es ist zu empfehlen, LTO beim Kompilieren im Release-Modus zu aktivieren. Dies resultiert in kleineren und schnelleren Binaries, erschwert aber das Debugging mit GDB sehr:
**** Oben die Configuration "Release" auswählen
**** In der 2. Baumstruktur "Optimization" auswählen
**** "Link-time optimizer (-flto)" aktivieren
**** Oben wieder "[All configurations]" anklicken
*** In der 2. Baumstruktur "Cross ARM C++ Compiler -> Optimization" anklicken
**** Rechts "Do not use exceptions (-fno-exceptions) anwählen
**** Rechts "Do not use RTTO (-fno-rtti)" anwählen
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "General" auswählen
**** In der Toolbar auf "Add" klicken, auf "Workspace" klicken, und das soeben in das Projekt kopierte Linkerscript auswählen.
*** In der 2. Baumstruktur "Cross ARM C++ Linker" -> "Miscellaneous" auswählen
**** Den Haken bei "Use newlib-nano (--specs=nano.specs)" setzen.
**** Optional, nur bei Cortex-M4 (zB STM32F3 und STM32F4):
***** Den Haken bei "Use float with with nano printf (-u _printf_float)" setzen. Dies ermöglicht die Nutzung von "%f" bei "printf", verbraucht aber automatisch eine Menge Flash+RAM und benötigt die Syscalls für malloc (s.u.). Daher ist ggf. zu empfehlen, dies nur in der Debug-Konfiguration zu aktivieren. Dazu in der Dropbown-Box oben vor aktivieren dieser Einstellung auf "Debug" klicken, und danach wieder auf "[All Configurations]".
*** Im Reiter "Devices" in der Baumstruktur den verwendeten Mikrocontroller, wie zB "STM32F407VG" auswählen.
** In der linken Baumstruktur "C/C++ General"->"Paths and Symbols" auswählen
*** Oben im Drop-Down-Menü "Debug" anklicken
*** Im Reiter "Symbols" rechts auf "Add" klicken und dadurch nacheinander folgende Symbole definieren. Dabei immer beide Häkchen setzen!
**** Name "HSE_VALUE" Value=Takt des Quarzes, z.B. 8000000
**** Name "USE_STDPERIPH_DRIVER" Value leerlassen
**** Name "__FPU_PRESENT" Value=1
**** Das zuvor gemerkte Präprozessor-Makro aus der "stm32f**.h" (zB. STM32F40_41xxx) Value leerlassen
**** Name "ARM_MATH_CM4", "ARM_MATH_CM3", "ARM_MATH_CM0", oder "ARM_MATH_CM0PLUS" je nachdem ob für den Cortex-M4, -M3, -M0, oder -M0+ kompiliert wird; Value leerlassen
** Das Fenster mit OK schließen.
Nun ist der Compiler an sich richtig konfiguriert. Allerdings fehlt noch die Library von ST:
* Die zuvor vorbereitete Standard Peripheral Library (d.h. das Verzeichnis "Libraries") in das Projektverzeichnis kopieren. Dies ist leider die einzig sinnvolle & einfache Möglichkeit.
* Den zuvor gesicherten Startup-Code, also zB. "startup_stm32f40_41xxx.S" in das Projektverzeichnis kopieren
* Die zuvor gesicherte Datei "stm32f***_conf.h" in das Projektverzeichnis kopieren
* Die zuvor generierte Datei "system_stm32f**" mit der Clock-Konfiguration in das Projektverzeichnis kopieren
Jetzt müssen dem Compiler noch die Pfade der Header-Dateien der Library mitgeteilt werden:
* Mit der rechten Maustaste auf den Projektnamen im linken Fenster anklicken, und "Properties" auswählen.
* Links in der Baumstruktur "C/C++ General" -> "Paths and Symbols" anklicken, und den Reiter "Includes" auswählen.
* Oben im Drop-Down-Menü "Debug" auswählen.
* Mit "Add" nacheinander folgende Pfade hinzufügen. Dazu jeweils "Add to all languages" sowie "Add to all configurations" einschalten, und den "Workspace..." Button verwenden.
** "Libraries/CMSIS/Device/ST/STM32F***/Include"
** "Libraries/CMSIS/Include"
** "Libraries/STM32F**_StdPeriph_Driver/inc"
** Den Pfad, in dem sich die "stm32f***_conf.h" befindet, also typischerweise das Projektverzeichnis selber.
* Mit OK das Fenster schließen. Danach wird Eclipse die C/C++ Analyse laufen lassen. Dies kann etwas dauern und die weitere Bedienung währenddessen verlangsamen. Der Fortschritt ist unten rechts im Fenster zu sehen.

=== Linkerscript anpassen ===
Noch einmal das soeben hineinkopierte Linkerscript (mit der Endung .ld) öffnen. Die Zeile mit "_Min_Heap_Size" gibt die Größe des Heaps, d.h. des für malloc() zur Verfügung stehenden Speichers an. Wird malloc() nicht verwendet, kann dies auf 0 gesetzt werden. Soll printf() verwendet werden, ist zu empfehlen hier mindestens 2048 anzugeben, da printf sonst schnell keinen Speicher mehr hat und es zu komischem Verhalten kommt:
<pre>_Min_Heap_Size = 2048; /* required amount of heap */</pre>

=== Optional: Syscalls implementieren ===
Soll im Code printf() und/oder malloc() verwendet werden können, müssen die [https://sourceware.org/newlib/libc.html#Syscalls Syscalls der C-Library] implementiert werden. Dazu ist es empfehlenswert, [[Media:Newlib cortexm syscalls.c|diesen Beispielcode]] zu verwenden und in das Projektverzeichnis zu kopieren. Er gibt per printf() ausgebenen Texte seriell per SWO aus. Dies ist ein Extra-Pin im SWD-Debug-Interface (bei JTAG nicht verfügbar), der vom JLink eingelesen und über die JLink-Software an Eclipse geschickt wird. Der Code kann auch angepasst werden um den Text zB per UART auszugeben.

== Code schreiben und kompilieren ==
Dem Projekt kann jetzt eine eigene Quellcodedatei hinzugefügt werden. Dazu mit der rechten Maustaste auf den Projektnamen klicken, "New"->"Source file" auswählen. Die Datei z.B. "main.c" (für C) oder "main.cpp" (für C++) nennen. [[Media:Stm32f4 eclipse example.c|Hier]] kann ein einfacher Beispielcode für den STM32F407 heruntergeladen werden (funktioniert sowohl mit C als auch C++), der eine LED am Pin PD15 blinken lässt (blaue LED auf dem [http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF252419 STM32F4 Discovery Board]). Der Code braucht auf jeden Fall eine "main()"-Funktion, sowie im Falle von C++ eine Funktion namens "__cxa_pure_virtual":
<syntaxhighlight lang="cpp">extern "C" void __cxa_pure_virtual () {
// This is an error callback for C++
__disable_irq ();
while (1) {
// Cause debugger breakpoint
asm volatile ("bkpt");
}
}</syntaxhighlight>
Wird die oben verlinkte syscalls.c Datei nicht eingebunden, wird außerdem auch noch eine _exit Funktion benötigt:
<syntaxhighlight lang="cpp">

#ifdef __cplusplus
extern "C"
void _exit(int) {
#else
void _exit (int status) {
((void) status);
#endif
// Stop controller in case of fatal error
__disable_irq ();
while (1) {
asm volatile ("bkpt");
}
__builtin_unreachable ();
}
</syntaxhighlight>
Dies sind Callbacks zur Fehlerbehandlung. Durch Überschreiben durch simples Blockieren des Controllers wird das Einbinden der komplexen Fehlerbehandlung der Standardbibliothek verhindert.
Danach kann der Code zum ersten Mal kompiliert werden. Dazu das Hammer-Symbol "Build" in der Toolbar benutzen. Fehlermeldungen sollten dem "Console" Fenster entnommen werden, da das "Problems" Fenster nicht immer korrekt funktioniert. Die erzeugten Dateien landen im Unterordner "Debug" bzw. "Release", je nachdem welche Konfiguration gewählt ist. Die generierte Datei mit der Endung .elf (zB Debug/MeinProjekt.elf) enthält den produzierten Code sowie alle Debug-Informationen. Es wird auch eine .hex Datei angelegt, die das erzeugte Flash-Image enthält.

== Debugging ==
=== Debug Configuration anlegen ===
Um den Code zu flashen und debuggen, wird eine Debug Configuration benötigt. Dazu im Menü auf "Run"->"Debug Configurations" klicken. Sollen sowohl Debug- als auch Release- Versionen so geflasht/debuggt werden, müssen mehrere Debug Configurations angelegt werden. Dazu ist es am einfachsten, eine anzulegen und mehrfach zu kopieren.
* Im erscheinenden Fenster in der Liste auf "GDB SEGGER J-Link Debugging" klicken, und oben auf das Symbol "New launch configuration".
* Im Reiter "Main", unter "C/C++ Application" den Pfad zum kompilierten ELF-File angeben, also zB "Debug/ProjektName.elf".
* Im Reiter "Startup" sollte "Enable SWO" aktiviert, und daneben die CPU-Frequenz in Hz angegeben werden (zB 168000000 für den STM32F4).
* Im Reiter "Common" kann in der Liste "Display in favorites menu" ein Haken bei "Debug" gesetzt werden. Dadurch ist diese Debug Configuration schneller über das Käfer-Symbol in der Toolbar im Hauptmenü zugänglich.
* Über "Apply" und "Close" das Fenster schließen.
=== Debug Session starten ===
[[Datei:Eclipse STM32 Debugging.png|right|thumb|Laufende Debug-Session]]* Auf das kleine schwarze Dreieck neben dem Käfer-Symbol ("Debug") in der Toolbar klicken, und die soeben angelegte Debug-Configuration auswählen. Eclipse wechselt nun in die Debug-Perspektive. Nach Beendigung der Debug-Session kann über den "C/C++"-Knopf oben rechts wieder in die normale Ansicht gewechselt werden.
* Es ist zu empfehlen die einzelnen Fenster der Ansicht so zu verschieben, dass mehr Code gleichzeitig sichtbar ist.
* Standardmäßig legt eclipse automatisch einen Breakpoint zu Beginn der "main" Funktion an.
* Über die Knöpfe "Resume", "Break", "Terminate" kann die Ausführung kontrolliert werden. Durch Doppelklick links neben eine Zeile werden Breakpoints gesetzt.
* Das ARM Plugin ermöglicht das Betrachten von Peripherie-Registern mit Trennung der einzelnen Felder. Dazu im Fenster "Peripherals" die Peripherie-Einheiten, deren Inhalt man betrachten möchte, auswählen. Im "Memory" Fenster werden dann die Register angezeigt. Die Ansicht wird immer nach jedem Ausführungsschritt aktualisiert, nicht immer sofort. Im Zweifelsfall also eine Zeile weiter laufen lassen, um die Ansicht zu aktualisieren.
* Ausgaben per "printf" erscheinen automatisch unten in der Konsole.

== Siehe auch ==
* [[STM32#Tutorials_f.C3.BCr_diverse_Tool-Kombinationen|Weitere Tutorials für STM32-IDE's]]
* [[ARM_GCC|Verwendung des GCC für Bare-Metal ARM]]
* [http://diller-technologies.de/stm32_wide.html Tutorial zur STM32 Programmierung]

Entprellung

2015-01-08T08:05:27Z

Kichi:

== Problembeschreibung ==
Mechanische [[Schalter]] wie [[Drehgeber]] neigen beim Ein- und Ausschalten zum sogenannten '''Prellen''', d.h sie schalten schnell mehrfach aus und ein, verursacht durch mechanische Vibrationen des Schaltkontaktes, sofern sie nicht dagegen geschützt sind. Vereinfacht dargestellt, sieht eine von einem Schalter oder Taster geschaltete Spannung beim Schalten wie folgt aus:

[[Bild:Entprellen.png]]

Für die Vermeidung bzw. Auswertung dieses unsauberen Signals gibt es verschiedene Ansätze:

== Hardwareentprellung ==

===Prellfreie Schalter===

Für Spezialanwendungen hält die elektromechanische Industrie verschiedene Sonderkonstruktionen bereit, die saubere Schaltzustände nach Aussen generieren, indem sie entweder eine mechanische Dämpfung in Form eines selbsthemmenden Federmechanismus oder eine integrierte elektronische Signalverzögerung benutzen.

Solche Systeme sind jedoch teuer und werden meist nur im Leistungsbereich eingesetzt.

===Wechselschalter===

Für die Entprellung von Wechselschaltern (engl. Double Throw Switch) kann ein klassisches RS-[[Flipflop]] genutzt werden. Bei dieser Variante werden neben zwei NAND-Gattern nur noch zwei Pull-Up Widerstände benötigt.

[[Bild:NAND_debouncer.png|thumb|left|350px|'''Taster entprellen mit NAND-RS-Flipflop''']]

 

In der gezeigten Schalterstellung liegt an der Position /S der Pegel 0 an. Damit ist das Flipflop gesetzt und der Ausgang auf dem Pegel 1. Schließt der Schalter zwischen den Kontakten 2 und 3, liegt an der Postion /R der Pegel 0 an. Dies bedeutet, dass der Ausgang des Flipflops auf den Pegel 0 geht. Sobald der Schalter von einem zum anderen Kontakt wechselt, beginnt er in der Regel zu prellen. Während des Prellens wechselt der Schalter zwischen den beiden Zuständen "Schalter berührt Kontakt" und "Schalter ist frei in der Luft". Der Ausgang des Flipflops bleibt in dieser Prellzeit aber stabil, da der Schalter während des Prellens nie den gegenüberliegenden Kontakt berührt und das RS-Flipflop seinen Zustand allein halten kann. Die Prellzeit ist stark vom Schaltertyp abhängig und liegt zwischen 0,1 und 10ms. Die Dimensionierung der Widerstände ist relativ unkritisch. Als Richtwert können hier 100kOhm verwendet werden.

====Wechselschalter ohne Flip-Flop====

Wenn man mal gerade kein Flip-Flop zur Hand hat, kann man sich auch mit dieser Schaltung behelfen.

[[Bild:WechselEntprellC.PNG|thumb|left|350px|'''Wechsler entprellen mit Kondensator''']]

 

Zur Funktionsweise:
Beim Umschalten wird der Kondensator immer sofort umgeladen.
Während der Kontakt prellt, befindet er sich in der Luft und hat keinerlei Verbindung. Während dieser Zeit übernimmt der Kondensator das halten des Pegels.

Dimensionierung:
Ist der entprellte Taster an ein IC Angeschlossen, ist der ''Input Leakage Current'' der ausschlaggebende Strom. Falls weitere Ströme fließen sind diese mit zu berücksichtigen. Bei einem Mikrocontroller von Atmel sind 1µA typisch.
Es gilt:
:<math>\frac{dU}{dt} = \frac{I}{C}</math>
Da eine Prellung ca. 10ms dauert und die Spannung in dieser Zeit beispielsweise um maximal 0,5V fallen soll kommt man auf folgende Kapazität:
:<math> C = \frac{I \cdot dt}{dU} = \frac{1\mu A \cdot 10ms}{0,5V} = 20nF </math>

Um Stromspitzen zu verringern kann ein Widerstand mit eingefügt werden. Eine Zeitkonstante von 1µs bis 1ms scheint sinnvoll. Also 500 Ohm bis 500kOhm sind nutzbar, wobei bei niedrigem Widerstand die Stromspitzen höher sind, und bei 500kOhm der Pinstrom störend wird.

===Einfacher Taster===

Auch wenn das RS-Flipflop sehr effektiv ist, wird diese Variante der Entprellung nur selten angewendet. Grund dafür ist, dass in Schaltungen häufiger einfache Taster eingesetzt werden. Diese sind oft kleiner und preisgünstiger. Um einfache Taster (engl. Single Throw Switch) zu entprellen, kann ein einfacher RC-Tiefpass eingesetzt werden. Hierbei wird ein Kondensator über einen Widerstand je nach Schalterstellung auf- oder entladen. Das RC-Glied bildet einen Tiefpass, sodass die Spannung über den Kondensator nicht von einen Pegel auf den anderen springen kann.

[[Bild:RC_debouncer.png|thumb|left|300px|Taster entprellen mit RC-Entpreller]]

[[Datei:Entprellen1a.png|thumb|350px| Entstehender Spannungsverlauf]]
{{Absatz}}

Wenn der Schalter geöffnet ist, lädt sich der Kondensator langsam über die beiden Widerstände R1 und R2 auf Vcc auf. Beim Erreichen der Umschaltschwelle springt der Ausgang auf den Pegel 0. Wird der Schalter geschlossen, entlädt sich der Kondensator langsam über den Widerstand R2. Demnach ändert sich der Ausgang des Inverters auf den Pegel 1. Während der Taster prellt, kann sich die Spannung über dem Kondensator nicht sprunghaft ändern, da das Auf- und Entladen eher langsam über die Widerstände erfolgt. Außerdem sind die Schaltschwellen für den Übergang LOW->HIGH und HIGH->LOW stark verschieden (Hysterese, siehe Artikel [[Schmitt-Trigger]]). Bei richtiger Dimensionierung der Bauelemente wird somit der Ausgang des Inverters prellfrei.

Zu beachten ist, dass der Inverter '''unbedingt''' einer mit [[Schmitt-Trigger]]-Eingängen sein muss, weil bei Standard-Logikeingängen im Bereich von üblicherweise 0,8V - 2,0V der Ausgang nicht definiert ist. Als Inverter kann zum Beispiel der 74HC14 oder der CD40106 (pinkompatibel) eingesetzt werden. Alternativ kann auch ein CD4093 eingesetzt werden. Bei dem CD4093 handelt es sich um NAND-Gatter mit Schmitt-Trigger-Eingängen. Um aus einem NAND-Gatter einen Inverter zu machen, müssen einfach nur die beiden Eingänge verbunden werden oder ein Eingang fest auf HIGH gelegt werden.

Für eine geeignete Dimensionierung muss man etwas mit den Standardformeln für einen Kondensator jonglieren. Die Spannung über den Kondensator beim Entladen berechnet sich nach:
:<math>U_C(t) = U_0 \cdot e^{\frac{-t}{R_2 C_1}}</math>

Damit der Ausgang des Inverters stabil ist, muss die Spannung über den Kondensator und damit die Spannung am Eingang des Inverters über der Spannung bleiben, bei welcher der Inverter umschaltet. Diese Schwellwertspannung ist genau die zeitabhängige Spannung über den Kondensator.
:<math>U_C(t)\!\ = U_{th}</math>

Durch Umstellen der Formel ergibt sich nun:
:<math>R_2=\frac{-t}{C_1 \cdot ln\left(\frac{U_{th}}{U_0} \right)}</math>

Ein Taster prellt üblicherweise etwa 10ms. Zur Sicherheit kann bei der Berechnung des Widerstandes eine Prellzeit von 20ms angenommen werden. U_0 ist die Betriebsspannung also Vcc. Die Schwellwertspannung muss aus dem Datenblatt des eingesetzten Schmitt-Triggers abgelesen werden. Beim 74HC14 beträgt der gesuchte Wert 2,0V. Nimmt man für den Kondensator 1µF und beträgt die Betriebsspannung 5V, ergibt sich für den Widerstand ein Wert von etwa 22kOhm.

Wird der Schalter geöffnet, lädt sich der Kondensator nach folgender Formel auf:
:<math>U_C(t) = U_0 \cdot \left( 1-e^{\frac{-t}{(R_1+R_2)\cdot C_1}} \right)</math>

Mit U_th=U_C ergibt das Umstellen nach (R_1+R_2):
:<math>R_1+R_2 = \frac{-t}{C_1 \cdot ln\left(1-\frac{U_{th}}{U_0} \right)} </math>

Für die Schwellspannung lässt sich aus dem Datenblatt ein Wert von 2,3V ablesen. Mit diesem Wert und den Annahmen von oben ergibt sich für R_1+R_2 ein Wert von 32kOhm. Somit ergibt sich für R_1 ein Wert von etwa 10kOhm.

Anmerkung: Beim 74LS14 von Hitachi z. B. sind die oberen und unteren Schaltschwellwerte unterschiedlich. Es muss darauf geachtet werden, dass U_{th} beim Entladen die untere Schwelle und U_{th} beim Laden die obere Schwelle einnimmt.

== Softwareentprellung ==

In den Zeiten der elektronischen Auswertung von Tastern und Schaltern ist das softwaretechnische Entprellen oft billiger, als die Benutzung eines teuren Schalters. Daher werden heute z.B. auch Computertastaturen nicht mehr mit prellarmen Tasten oder Entprellkondensatoren ausgestattet.

Bei Verwendung des in den meisten Geräten ohnehin vorhandenen Mikrocontrollers z.B., kann man sich die zusätzliche Hardware sparen, da die Entprellung in Software praktisch genauso gut funktioniert. Dabei ist nur zu beachten, dass zusätzliche Rechenleistung und je nach Umsetzung auch einige Hardwareressourcen (z.B. Timer) benötigt werden.

=== Flankenerkennung ===
Bei einem Taster gibt es insgesamt 4 theoretische Zustände:

* 1. war nicht gedrückt und ist nicht gedrückt
* 2. war nicht gedrückt und ist gedrückt (steigende Flanke)
* 3. war gedrückt und ist immer noch gedrückt
* 4. war gedrückt und ist nicht mehr gedrückt (fallende Flanke)

Diese einzelnen Zustände lassen sich jetzt bequem abfragen/durchlaufen. Die Entprellung geschieht dabei durch die ganze Laufzeit des Programms. Die Taster werden hierbei als Active-Low angeschlossen, um die internen Pull-Ups zu nutzen.

Diese Routine gibt für den Zustand "steigende Flanke" den Wert "1" zurück, sonst "0"

<syntaxhighlight lang="c">
#define TASTERPORT PINC
#define TASTERBIT PINC1

char taster(void)
{
static unsigned char zustand;
char rw = 0;

if(zustand == 0 && !(TASTERPORT & (1<<TASTERBIT))) //Taster wird gedrueckt (steigende Flanke)
{
zustand = 1;
rw = 1;
}
else if (zustand == 1 && !(TASTERPORT & (1<<TASTERBIT))) //Taster wird gehalten
{
zustand = 2;
rw = 0;
}
else if (zustand == 2 && (TASTERPORT & (1<<TASTERBIT))) //Taster wird losgelassen (fallende Flanke)
{
zustand = 3;
rw = 0;
}
else if (zustand == 3 && (TASTERPORT & (1<<TASTERBIT))) //Taster losgelassen
{
zustand = 0;
rw = 0;
}

return rw;
}
</syntaxhighlight>

Eine Erweiterung, damit beliebig lange das Halten einer Taste erkannt wird kann man ganz einfach so implementieren:

<syntaxhighlight lang="c">
// zustand kann entweder zum ersten mal als gehalten detektiert werden oder aber jedes weitere mal
else if (((zustand == 1) || (zustand == 2)) && !(TASTERPORT & (1<<TASTERBIT))) //Taster wird gehalten
{
zustand = 2;
rw = 0;
}
</syntaxhighlight>

=== Warteschleifen-Verfahren ===

Soll nun mit einem Mikrocontroller gezählt werden, wie oft ein Kontakt oder ein Relais geschaltet wird, muss das Prellen des Kontaktes exakt berücksichtigt - und von einem gewollten Mehrfachschalten abgegrenzt werden, da sonst möglicherweise Fehlimpulse gezählt- oder andererseits echte Schaltvorgänge übersprungen werden. Dies muss beim Schreiben des Programms hinsichtlich des Abtastens des Kontaktes unbedingt Rechnung getragen werden.

Beim folgenden einfachen Beispiel für eine Entprellung ist zu beachten, dass der AVR im Falle eines Tastendrucks 200ms wartet, also brach liegt. Bei zeitkritischen Anwendungen sollte man ein anderes Verfahren nutzen (z. B. Abfrage der Tastenzustände in einer Timer-Interrupt-Service-Routine).

<syntaxhighlight lang="c">
#include <avr/io.h>
#include <inttypes.h>
#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun mit 3686400 definiert"
#define F_CPU 3686400UL /* Quarz mit 3.6864 Mhz */
#endif
#include <util/delay.h> /* bei alter avr-libc: #include <avr/delay.h> */

/* Einfache Funktion zum Entprellen eines Tasters */
inline uint8_t debounce(volatile uint8_t *port, uint8_t pin)
{
if ( !(*port & (1 << pin)) )
{
/* Pin wurde auf Masse gezogen, 100ms warten */
_delay_ms(50); // Maximalwert des Parameters an _delay_ms
_delay_ms(50); // beachten, vgl. Dokumentation der avr-libc
if ( *port & (1 << pin) )
{
/* Anwender Zeit zum Loslassen des Tasters geben */
_delay_ms(50);
_delay_ms(50);
return 1;
}
}
return 0;
}

int main(void)
{
DDRB &= ~( 1 << PB0 ); /* PIN PB0 auf Eingang Taster) */
PORTB |= ( 1 << PB0 ); /* Pullup-Widerstand aktivieren */
...
if (debounce(&PINB, PB0))
{
/* Falls Taster an PIN PB0 gedrueckt */
/* LED an Port PD7 an- bzw. ausschalten: */
PORTD = PORTD ^ ( 1 << PD7 );
}
...
}
</syntaxhighlight>

Die obige Routine hat leider mehrere Nachteile:
* sie detektiert nur das Loslassen (unergonomisch)
* sie verzögert die Mainloop immer um 100ms bei gedrückter Taste
* sie verliert Tastendrücke, je mehr die Mainloop zu tun hat.

Eine ähnlich einfach zu benutzende Routine, aber ohne all diese Nachteile findet sich im Forenthread
[http://www.mikrocontroller.net/topic/164194#new Entprellung für Anfänger]

Der ''DEBOUNCE'' Befehl in dem BASIC-Dialekt BASCOM für AVR ist ebenfalls nach dem Warteschleifen-Verfahren programmiert. Die Wartezeit beträgt standardmäßig 25 ms, kann aber vom Anwender überschrieben werden. Vgl. [http://avrhelp.mcselec.com/bascom-avr.html?DEBOUNCE BASCOM Online-Manual zu DEBOUNCE].

Eine C-Implementierung für eine Tastenabfrage mit Warteschleife ist im Artikel [[AVR-GCC-Tutorial#IO-Register_als_Parameter_und_Variablen|AVR-GCC-Tutorial: IO-Register als Parameter und Variablen]] angeben.

Der Nachteil dieses Verfahrens ist, dass der Controller durch die Warteschleife blockiert wird. Günstiger ist die Implementierung mit einem Timer-Interrupt.

==== Warteschleifenvariante mit Maske und Pointer (nach Christian Riggenbach) ====

Hier eine weitere Funktion, um Taster zu entprellen: Durch den zusätzlichen Code kann eine Entprellzeit von durchschnittlich 1-3ms (mindestens 8*150µs = 1ms) erreicht werden. Grundsätzlich prüft die Funktion den Pegel der Pins auf einem bestimmten Port. Wenn die/der Pegel 8 Mal konstant war, wird die Schleife verlassen. Diese Funktion kann sehr gut eingesetzt werden, um in einer Endlosschleife Taster anzufragen, da sie, wie erwähnt, eine kurze Wartezeit hat.

<syntaxhighlight lang="c">
void entprellung( volatile uint8_t *port, uint8_t maske ) {
uint8_t port_puffer;
uint8_t entprellungs_puffer;

for( entprellungs_puffer=0 ; entprellungs_puffer!=0xff ; ) {
entprellungs_puffer<<=1;
port_puffer = *port;
_delay_us(150);
if( (*port & maske) == (port_puffer & maske) )
entprellungs_puffer |= 0x01;
}
}
</syntaxhighlight>
Die Funktion wird wie folgt aufgerufen:
<syntaxhighlight lang="c">
// Bugfix 20100414
// http://www.nongnu.org/avr-libc/user-manual/FAQ.html#faq_port_pass
entprellung( &PINB, (1<<PINB2) ); // ggf. Prellen abwarten
if( PINB & (1<<PINB2) ) // dann stabilen Wert einlesen
{
// mach was
}
else
{
// mach was anderes
}
</syntaxhighlight>
Als Maske kann ein beliebiger Wert übergeben werden. Sie verhindert, dass nichtverwendete Taster die Entprellzeit negativ beeinflussen.

==== Debounce-Makro von Peter Dannegger ====

Peter Dannegger hat in [http://www.mikrocontroller.net/topic/164194#1566921 "Entprellen für Anfänger"] folgende vereinfachtes Entprellverfahren beschrieben. Das Makro arbeitet in der Originalversion mit ''active low'' geschalteten Tastern, kann aber einfach für ''active high'' geschaltete Taster angepasst werden ([[Pollin Funk-AVR-Evaluationsboard#Tasty Reloaded|Tasty Reloaded]]).

<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Not so powerful Debouncing Example */
/* No Interrupt needed */
/* */
/* Author: Peter Dannegger */
/* */
/************************************************************************/
// Target: ATtiny13

#include <avr/io.h>
#define F_CPU 9.6e6
#include <util/delay.h>

#define debounce( port, pin ) \
({ \
static uint8_t flag = 0; /* new variable on every macro usage */ \
uint8_t i = 0; \
\
if( flag ){ /* check for key release: */ \
for(;;){ /* loop ... */ \
if( !(port & 1<<pin) ){ /* ... until key pressed or ... */ \
i = 0; /* 0 = bounce */ \
break; \
} \
_delay_us( 98 ); /* * 256 = 25ms */ \
if( --i == 0 ){ /* ... until key >25ms released */ \
flag = 0; /* clear press flag */ \
i = 0; /* 0 = key release debounced */ \
break; \
} \
} \
}else{ /* else check for key press: */ \
for(;;){ /* loop ... */ \
if( (port & 1<<pin) ){ /* ... until key released or ... */ \
i = 0; /* 0 = bounce */ \
break; \
} \
_delay_us( 98 ); /* * 256 = 25ms */ \
if( --i == 0 ){ /* ... until key >25ms pressed */ \
flag = 1; /* set press flag */ \
i = 1; /* 1 = key press debounced */ \
break; \
} \
} \
} \
i; /* return value of Macro */ \
})

/*
Testapplication
*/
int main(void)
{
DDRB &= ~(1<<PB0);
PORTB |= 1<<PB0;
DDRB |= 1<<PB2;
DDRB &= ~(1<<PB1);
PORTB |= 1<<PB1;
DDRB |= 1<<PB3;
for(;;){
if( debounce( PINB, PB1 ) )
PORTB ^= 1<<PB2;
if( debounce( PINB, PB0 ) )
PORTB ^= 1<<PB3;
}
}

</syntaxhighlight>

Wenn das Makro für die gleiche Taste (Pin) an mehreren Stellen aufgerufen werden soll, muss eine Funktion angelegt werden, damit beide Aufrufe an die gleiche Zustandsvariable ''flag'' auswerten [http://www.mikrocontroller.net/topic/195914#1918727]:

<syntaxhighlight lang="c">
// Hilfsfunktion
uint8_t debounce_C1( void )
{
return debounce(PINC, PC1);
}

// Beispielanwendung
int main(void)
{
DDRB |= 1<<PB2;
DDRB |= 1<<PB3;
DDRC &= ~(1<<PC1);
PORTC |= 1<<PC1; // Pullup für Taster

for(;;){
if( debounce_C1() ) // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB2;
if( debounce_C1() ) // nicht: debounce(PINC, PC1)
PORTB ^= 1<<PB3;
}
}
</syntaxhighlight>

=== Timer-Verfahren (nach Peter Dannegger) ===

==== Grundroutine (AVR Assembler) ====

Siehe dazu: [http://www.mikrocontroller.net/forum/read-4-20435.html#new Forum]

Vorteile
* besonders kurzer Code
* schnell

Außerdem können 8 Tasten (aktiv low) gleichzeitig bearbeitet werden, es dürfen also
alle exakt zur selben Zeit gedrückt werden. Andere Routinen können z. B. nur eine Taste verarbeiten, d.h. die zuerst oder zuletzt gedrückte gewinnt, oder es kommt Unsinn heraus.

Die eigentliche Einlese- und Entprellroutine ist nur 8 Instruktionen
kurz. Der entprellte Tastenzustand ist im Register ''key_state''. Mit nur 2 weiteren Instruktionen wird dann der Wechsel von ''Taste offen'' zu
''Taste gedrückt'' erkannt und im Register ''key_press'' abgelegt. Im Beispielcode werden dann damit 8 LEDs ein- und ausgeschaltet. Jede Taste entspricht einem Bit in den Registern, d.h. die Verarbeitung erfolgt bitweise mit logischen Operationen. Zum Verständnis empfiehlt es sich daher, die Logikgleichungen mit Gattern für ein Bit = eine Taste aufzumalen. Die Register kann man sich als Flipflops denken, die mit der Entprellzeit als Takt arbeiten. D.h. man kann das auch so z. B. in einem GAL22V10 realisieren.

Als Kommentar sind neben den einzelnen Instruktionen alle 8 möglichen
Kombinationen der 3 Signale dargestellt.

Beispielcode für AVR (Assembler):

<syntaxhighlight lang="avrasm">
.nolist
.include "c:\avr\inc\1200def.inc"
.list
.def save_sreg = r0
.def iwr0 = r1
.def iwr1 = r2

.def key_old = r3
.def key_state = r4
.def key_press = r5

.def leds = r16
.def wr0 = r17

.equ key_port = pind
.equ led_port = portb

rjmp init
.org OVF0addr ;timer interrupt 24ms
in save_sreg, SREG
get8key: ;/old state iwr1 iwr0
mov iwr0, key_old ;00110011 10101010 00110011
in key_old, key_port ;11110000
eor iwr0, key_old ; 11000011
com key_old ;00001111
mov iwr1, key_state ; 10101010
or key_state, iwr0 ; 11101011
and iwr0, key_old ; 00000011
eor key_state, iwr0 ; 11101000
and iwr1, iwr0 ; 00000010
or key_press, iwr1 ;store key press detect
;
; insert other timer functions here
;
out SREG, save_sreg
reti
;-------------------------------------------------------------------------
init:
ldi wr0, 0xFF
out ddrb, wr0
ldi wr0, 1<<CS02 | 1<<CS00 ;divide by 1024 * 256
out TCCR0, wr0
ldi wr0, 1<<TOIE0 ;enable timer interrupt
out TIMSK, wr0

clr key_old
clr key_state
clr key_press
ldi leds, 0xFF
main: cli
eor leds, key_press ;toggle LEDs
clr key_press ;clear, if key press action done
sei
out led_port, leds
rjmp main
;-------------------------------------------------------------
</syntaxhighlight>

==== Komfortroutine (C für AVR) ====

Siehe dazu: [http://www.mikrocontroller.net/forum/read-4-310276.html Forum]

'''Anmerkung''' Wenn statt active-low (Ruhezustand High) active-high (Ruhezustand Low) verwendet wird muss eine Zeile geändert werden siehe:
[http://www.mikrocontroller.net/forum/read-4-310276.html gesamter Beitrag im Forum],
[http://www.mikrocontroller.net/topic/48465#606555 Stelle 1 im Beitrag], ([http://www.mikrocontroller.net/topic/48465#2306398 Stelle 2 im Beitrag] muss *nicht* geändert werden, da hier die Polarität gar keinen Einfluß hat).

'''Anmerkung 2''' Zur Initialisierung siehe [http://www.mikrocontroller.net/topic/48465#3572793 Forum]

Funktionsprinzip wie oben plus zusätzliche Features:
* Kann Tasten sparen durch unterschiedliche Aktionen bei kurzem oder langem Drücken
* Wiederholfunktion, z. B. für die Eingabe von Werten

Das Programm ist für avr-gcc/avr-libc geschrieben, kann aber mit ein paar Anpassungen auch mit anderen Compilern und Mikrocontrollern verwendet werden. Eine Portierung für den AT91SAM7 findet man [http://www.google.com/codesearch?q=show:ac2viP-2E2Y:pzkOO5QRsoc:RPICuprYy-A&sa=N&cd=1&ct=rc&cs_p=svn://mikrocontroller.net/mp3dec/trunk&cs_f=keys.c#a0 hier] (aus dem Projekt [[ARM MP3/AAC Player]]).
<syntaxhighlight lang="c">
/************************************************************************/
/* */
/* Debouncing 8 Keys */
/* Sampling 4 Times */
/* With Repeat Function */
/* */
/* Author: Peter Dannegger */
/* danni@specs.de */
/* */
/************************************************************************/

#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#ifndef F_CPU
#define F_CPU 1000000 // processor clock frequency
#warning kein F_CPU definiert
#endif

#define KEY_DDR DDRB
#define KEY_PORT PORTB
#define KEY_PIN PINB
#define KEY0 0
#define KEY1 1
#define KEY2 2
#define ALL_KEYS (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK (1<<KEY1 | 1<<KEY2) // repeat: key1, key2
#define REPEAT_START 50 // after 500ms
#define REPEAT_NEXT 20 // every 200ms

#define LED_DDR DDRA
#define LED_PORT PORTA
#define LED0 0
#define LED1 1
#define LED2 2

volatile uint8_t key_state; // debounced and inverted key state:
// bit = 1: key pressed
volatile uint8_t key_press; // key press detect

volatile uint8_t key_rpt; // key long press and repeat

ISR( TIMER0_OVF_vect ) // every 10ms
{
static uint8_t ct0, ct1, rpt;
uint8_t i;

TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms

i = key_state ^ ~KEY_PIN; // key changed ?
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
i &= ct0 & ct1; // count until roll over ?
key_state ^= i; // then toggle debounced state
key_press |= key_state & i; // 0->1: key press detect

if( (key_state & REPEAT_MASK) == 0 ) // check repeat function
rpt = REPEAT_START; // start delay
if( --rpt == 0 ){
rpt = REPEAT_NEXT; // repeat delay
key_rpt |= key_state & REPEAT_MASK;
}
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_press; // read key(s)
key_press ^= key_mask; // clear key(s)
sei();
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
cli(); // read and clear atomic !
key_mask &= key_rpt; // read key(s)
key_rpt ^= key_mask; // clear key(s)
sei();
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )

{
key_mask &= key_state;
return key_mask;
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
cli(); // read key state and key press atomic !
return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
return get_key_press( get_key_rpt( key_mask ));
}

int main( void )
{
LED_PORT = 0xFF;
LED_DDR = 0xFF;

// Configure debouncing routines
KEY_DDR &= ~ALL_KEYS; // configure key port for input
KEY_PORT |= ALL_KEYS; // and turn on pull up resistors

TCCR0 = (1<<CS02)|(1<<CS00); // divide by 1024
TCNT0 = (uint8_t)(int16_t)-(F_CPU / 1024 * 10e-3 + 0.5); // preload for 10ms
TIMSK |= 1<<TOIE0; // enable timer interrupt

sei();

while(1){
if( get_key_short( 1<<KEY1 ))
LED_PORT ^= 1<<LED1;

if( get_key_long( 1<<KEY1 ))
LED_PORT ^= 1<<LED2;

// single press and repeat

if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 )){
uint8_t i = LED_PORT;

i = (i & 0x07) | ((i << 1) & 0xF0);
if( i < 0xF0 )
i |= 0x08;
LED_PORT = i;
}
}
}
</syntaxhighlight>

Das single-press-und-repeat-Beispiel geht nicht in jeder Beschaltung; folgendes Beispiel sollte universeller sein (einzelne LED an/aus):
<syntaxhighlight lang="c">
// single press and repeat
if( get_key_press( 1<<KEY2 ) || get_key_rpt( 1<<KEY2 ))
LED_PORT ^=0x08;
</syntaxhighlight>

===== Funktionsweise =====
Der Code basiert auf 8 parallelen vertikalen Zählern, die über die Variablen ct0 und ct1 aufgebaut werden

[[Bild:VertCount.png|framed|center|'''8 vertikale Zähler in 2 8-Bit Variablen''']]

wobei jeweils ein Bit in ct0 mit dem gleichwertigen Bit in ct1 zusammengenommen einen 2-Bit-Zähler bildet.
Der Code der sich um die 8 Zähler kümmert, ist so geschrieben, daß er alle 8 Zähler gemeinsam parallel behandelt.

<syntaxhighlight lang="c">
i = key_state ^ ~KEY_PIN; // key changed ?
</syntaxhighlight>
i enthält an dieser Stelle für jede Taste, die sich im Vergleich mit dem vorhergehenden entprellten Zustand (keystate) verändert hat, ein 1 Bit.

<syntaxhighlight lang="c">
ct0 = ~( ct0 & i ); // reset or count ct0
ct1 = ct0 ^ (ct1 & i); // reset or count ct1
</syntaxhighlight>

Diese beiden Anweisungen erniedrigen den 2-Bit Zähler ct0/ct1 für jedes Bit um 1, welches in i gesetzt ist. Liegt an der entsprechenden Stelle in i ein 0 Bit vor (keine Änderung des Zustands), so wird der Zähler ct0/ct1 für dieses Bit auf 1 gesetzt.
Der Grundzustand des Zählers ist als ct0 == 1 und ct1 == 1 (Wert 3). Der Zähler zählt daher mit jedem ISR Aufruf, bei dem die Taste im Vergleich zu keystate als verändert erkannt wurde

ct1 ct0
1 1 // 3
1 0 // 2
0 1 // 1
0 0 // 0
1 1 // 3

<syntaxhighlight lang="c">
i &= ct0 & ct1; // count until roll over ?
</syntaxhighlight>
in i bleibt nur dort ein 1-Bit erhalten, wo sowohl in ct1 als auch in ct0 ein 1 Bit vorgefunden wird, der betreffende Zähler also bis 3 zählen konnte. Durch die zusätzliche Verundung mit i wird der Fall abgefangen, dass ein konstanter Zählerwert von 3 in i ein 1 Bit hinterlässt. Im Endergebnis bedeutet dass, dass nur ein Zählerwechsel von 0 auf 3 zu einem 1 Bit an der betreffenden Stelle in i führt, aber auch nur dann, wenn in i an dieser Bitposition ebenfalls ein 1 Bit war (welches wiederrum deswegen auf 1 war, weil an diesem Eingabeport eine Veränderung zum letzten bekannten entprellten Zustand festgestellt wurde). Alles zusammengenommen heißt das, dass ein Tastendruck dann erkannt wird, wenn die Taste 4 mal hintereinander in einem anderen Zustand vorgefunden wurde als dem zuletzt bekannten entprellten Tastenzustand.

An dieser Stelle ist i daher ein Vektor von 8 Bits, von denen jedes einzelne der Bits darüber Auskunft gibt, ob die entsprechende Taste mehrmals hintereinander im selben Zustand angetroffen wurde, der nicht mit dem zuletzt bekannten Tastenzustand übereinstimmt. Ist das der Fall, dann wird eine entsprechende Veränderung des Tastenzustands in key_state registriert
<syntaxhighlight lang="c">
key_state ^= i; // then toggle debounced state
</syntaxhighlight>
und wenn sich in key_state das entsprechende Bit von 0 auf 1 verändert hat, wird dieses Ereignis als 'Taste wurde niedergedrückt' gewertet.
<syntaxhighlight lang="c">
key_press |= key_state & i; // 0->1: key press detect
</syntaxhighlight>

Damit ist der Tasteneingang entprellt. Und zwar sowohl beim Drücken einer Taste als auch beim Loslassen (damit Tastenpreller beim Loslassen nicht mit dem Niederdrücken einer Taste verwechselt werden). Der weitere Code beschäftigt sich dann nur noch damit, diesen entprellten Tastenzustand weiter zu verarbeiten.

Der Codeteil sieht durch die Verwendung der vielen bitweisen Operationen relativ komplex aus. Behält man aber im Hinterkopf, dass einige der bitweisen wie ein 'paralles If' gleichzeitig auf allen 8 Bits eingesetzt werden, dann vereinfacht sich vieles. Ein
<syntaxhighlight lang="c">
key_press |= key_state & i;
</syntaxhighlight>
ist nichts anderes als ein
<syntaxhighlight lang="c">
// teste ob Bit 0 sowohl in key_state als auch in i gesetzt ist
// und setze Bit 0 in key_press, wenn das der Fall ist
if( ( key_state & ( 1 << 0 ) ) &&
( i & ( 1 << 0 ) )
key_press |= ( 1 << 0 );

// Bit 1
if( ( key_state & ( 1 << 1 ) ) &&
( i & ( 1 << 1 ) )
key_press |= ( 1 << 1 );

// Bit 2
if( ( key_state & ( 1 << 2 ) ) &&
( i & ( 1 << 2 ) )
key_press |= ( 1 << 2 );

...
</syntaxhighlight>
nur als wesentlich kompaktere Operation ausgeführt und für alle 8 Bits gleichzeitig.
Die Kürze und Effizienz dieser paar Codezeilen ergibt sich aus dem Umstand, dass jedes Bit in den Variablen für eine Taste steht und alle 8 (maximal möglichen) Tasten gleichzeitig die Operationen durchlaufen.

===== Reduziert auf lediglich 1 Taste =====
Diskussionen im Forum zeigen immer wieder, dass viele eine Abneigung gegen diesen Code haben, weil er ihnen sehr kompliziert vorkommt.

Der Code ist nicht leicht zu analysieren und er zieht alle Register dessen, was möglich ist, um sowohl Laufzeit als auch Speicherverbrauch einzusparen. Oft hört man auch das Argument: Ich benötige ja nur eine Entprellung für 1 Taste, gibt es da nichts Einfacheres?

Hier ist die 'Langform' des Codes, so wie man das für lediglich 1 Taste schreiben würde, wenn man exakt dasselbe Entprellverfahren einsetzen würde. Man sieht: Da ist keine Hexerei dabei: In key_state wird der letzte bekannte entprellte Zustand der Taste gehalten. Der Pin-Eingang wird mit diesem Zustand verglichen und wenn sich die beiden unterscheiden, dann wird ein Zähler heruntergezählt. Produziert dieses herunterzählen einen Unterlauf des Zählers, dann gilt die Taste als entprellt und wenn dann auch noch die Taste gerade gedrückt ist, dann wird dieses in key_press entsprechend vermerkt.

<syntaxhighlight lang="c">
uint8_t key_state;
uint8_t key_counter;
volatile uint8_t key_press;

ISR( ... Overflow ... )
{
uint8_t input = KEY_PIN & ( 1 << KEY0 );

if( input != key_state ) {
key_counter--;
if( key_counter == 0xFF ) {
key_counter = 3;
key_state = input;
if( input )
key_press = TRUE;
}
}
else
key_counter = 3;

}

uint8_t get_key_press()
{
uint8_t result;

cli();
result = key_press;
key_press = FALSE;
sei();

return result;
}
</syntaxhighlight>

Der vollständige Entprellcode, wie weiter oben gelistet, besticht jetzt aber darin, dass er compiliert kleiner ist als diese anschaulichere Variante für lediglich 1 Taste. Und das bei gleichzeitig erhöhter Funktionalität. Denn zb. ein Autorepeat ist in diesem Code noch gar nicht eingebaut. Und spätestens wenn man dann eine 2.te Taste entprellen möchte, dann ist auch der SRAM-Speicherverbrauch dieser Langform höher als der des Originals für 8 Tasten. Daraus folgt: Selbst für lediglich 1 Taste ist die Originalroutine die bessere Wahl.

Und wegen der Komplexität mal eine Frage: Sind Sie selbst in der Lage eine entsprechend effiziente sqrt() Funktion zu schreiben, wie die, die sie in der Standard-C-Bibliothek vorfinden? Nein? Dann dürften Sie eigentlich Ihrer Argumentation nach die Bibliotheksfunktion sqrt() nicht verwenden, sondern müssten sich statt dessen selbst eine Wurzel-Funktion schreiben.

=== Selbstsättigender Filter (nach Jürgen Schuhmacher) ===
Durch die Nutzung der diskreten Signalanalyse in Software kann die Funktionalität einer einfachen Entprellung mit einem Widerstand, einem Kondensator und einem Schmitttrigger wie in Hardware nachgebildet werden, indem ein abstrakter IIR-Filter benutzt wird, der eine Kondensatorladekurve emuliert. Mit der Vorschrift Y(t) = k Y(t-1) + Input wird ein einfaches Filter erzeugt, dass dem Eingangswert träge folgt. Bei Überschreiten eines bestimmten Wertes erfolgt mit einer einfachen Abfrage das Schalten des Ausgangssignals.

Für Assembler und VHDL bei FPGAs eignet sich aufgrund der leicht zu implementierenden binären Operationen folgende Darstellung mit einer Auflösung des Filterwertspeichers von nur 8 bit: Wert_Neu = Wert_Alt - Wert_Alt/16 + 16*(Taste = True). Der Filterwert bildet dann den gedämpften Verlauf des Eingangs (flankenverschliffen) ab und kann Prellen bis nahe an den Grenzbereich zum schnellen Tasten unterdrücken. Der Ausgangswert ist dann einfach das höchstwertige Bit des Filterwertes.

[[Datei:Entprellung mit IIR-Filter.gif]]

Dazu muss das Signal des Tasters idealerweise um den Faktor 10-20 schneller abgetastet werden, als die höchste gewünschte Tippgeschwindigkeit vorgibt. Noch schneller abzutasten ist möglich, führt aber zu mehr Bedarf an Bits beim Filter. Die Schmittriggerfunktion kann dadurch gebildet werden, dass eine 1 am Ausgang bei z.B. Überschreiten einer 55% Grenze und eine 0 bei Unterschreitung der 45%-Grenze ausgeben wird. Im Zwischenbereich wird der alte Wert gehalten.

=== Einfacher Mittelwertfilter (nach Lothar Miller) ===
Für digitale Schaltungen oder PLDs empfiehlt sich ein FIR-Filter mit aneinandergereihten FlipFlops. Man schiebt das Eingangssignal in eine FlipFlop-Kette und schaltet oberhalb der Mitte um:

SignalInput -> FF1 -> FF2 -> FF3 -> FF4 -> FF5 -> FF6 -> FF7 -> FF8

Wenn alle FFs = 1 (Summe der FFs=8) dann SignalOutput = 1 
Wenn alle FFs = 0 (Summe der FFs=0) dann SignalOutput = 0

Dieses Verfahren kann sehr einfach in Logik abgebildet werden, weil für die Berechnung des Ausgangs nur ein NOR bz. ein AND Gatter nötig ist.

== Gegenüberstellung der Verfahren ==
* HW - "entprellte Schalter": Sehr teuer, grosse Bauform, verschleissbelastet, geringe Haltbarkeit
* HW - "Umschalter" : benötigt aufwändigeren Schalter, benötigt Elektronik
* HW - "Umschalter ohne FF" : benötigt aufwändigeren Schalter und kleiner Kondensator
* HW - "Kondensatorentprellung" : benötigt etwas mehr Platz, kommt mit schlechten Schaltern zurecht

* SW - Flankenverfahren:
* SW - Warteschleife: Durch die Warteschleifen eine nicht zu vernachlässigende Verzögerung im Code. Speziell wenn mehrere Tasten zu überwachen sind, nicht unproblematisch
* SW - Timer: Universalfunktionalität, die durch geringen Speicherverbrauch, geringen Rechenzeitverbrauch und gute Funktion besticht. Der 'Verbrauch' eines Timers sieht auf den ersten Blick schlimmer aus, als er ist, denn in den meisten Programmen hat man sowieso einen Basistimer für die Zeitsteuerung des Programms im Einsatz, der für die Tastenentprellung mitbenutzt werden kann.
* SW - Filter: sehr geringer Platzbedarf in FPGAs, relativ gute Wirkung
* SW - Filter 2: sehr geringer Platzbedarf, gute Wirkung

== Links zum Thema ==

* [http://www.edn.com/design/analog/4324067/Contact-debouncing-algorithm-emulates-Schmitt-trigger Contact-debouncing algorithm (Artikel)], [http://www.edn.com/file/13370-70705di.pdf als PDF]
* [[AVR-Tutorial: Tasten]]
* [[AVR-GCC-Tutorial#.28Tasten-.29Entprellung|AVR-GCC-Tutorial Tastenentprellung]]
* [http://www.mikrocontroller.net/forum/read-4-20435.html Beitrag im Forum, AVR Assembler]
* [http://www.ganssle.com/debouncing.pdf A guide to debouncing (engl.), praktische Erläuterungen zum Entprellen in Soft- und Hardware]
* [http://www.pololu.com/docs/0J16/all Understanding Destructive LC Voltage Spikes]

[[Kategorie:AVR]]
[[Kategorie:Signalverarbeitung]]

STM32 USB-FS-Device Lib

2014-11-10T13:20:34Z

Kichi:

===STM32 USB-FS-Device Lib===

Mit der ''STM32 USB-FS-Device Lib'' stellt ST C-Funktionen zur Benutzung der [[USB]]-Schnittstelle der STM32 µC zur Verfügung.

Sie kann zusammen mit Beispielimplementationen verschiedener USB-Geräteklassen hier bei ST kostenlos heruntergeladen werden:
* [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/Attachments/23342/STM32_USB-FS-Device_Lib_V3.3.0.zip STM32_USB-FS-Device_Lib_V3.3.0]
* [http://www.st.com/web/en/catalog/tools/FM147/CL1794/SC961/SS1743/PF258157?s_searchtype=keyword# STM32_USB-FS-Device_Lib_V4.0.0]

Eine Beschreibung findet sich [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/user_manual/CD00158241.pdf hier].

==Virtual COM Port==
Für die allgemeine Kommunikation mit einem PC wird für die meisten Projekte ein Virtual COMPORT die geeignete Geräteklasse sein.
Auf PC Seite erscheint dabei nach Einstecken des STM32 in den USB Port ein weiterer COM Port im Gerätemanager, der von Applikationen genauso wie jeder reale COM Port verwendet werden kann. Wie der Zugriff auf µC-Seite aussieht sehen wir uns weiter unten an.

===Die Beispielimplementierung===
ST liefert eine Beispielimplementierung für den einen Virtual Comport mit der USB-Lib mit. Um diese Nutzen zu können, muss das verwendete Evalboard einmal mit dem USB und einmal mit einem echten RS232 verbunden sein, da man zum Test Daten zwischen zwei Terminalprogrammen hin- und herschicken kann, eines mit dem Virtual COM Port und das andere mit dem "echten" COM Port verbunden.

Da ich derzeit keinen weiteren COM Ports zur Verfügung hatte und ich gerne ein Beispiel wollte, das rein auf den USB-Port konzentriert ist, habe ich das Beispiel etwas modifiziert. In meinem Beispielprogramm sind alle USART Anteile entfernt, ebenso alle #ifdefs die sich auf ein bestimmtes EVAL-Board bzw. auf den STM32 in der Connectivity Line beziehen, welche einen USB-OnTheGo besitzt. Dadurch ist der Code jetzt deutlich leichter zu überschauen. (wenn ihr unbedingt einen STM32 aus der Connectivity Line nehmen wollt, dann quält euch durch das Orginalbeispiel.

In der jetzigen Version schickt der µC jede Zeichenkette die ihm vom PC geschickt wird wieder an den selben COM Port zurück, aber in umgekehrter Zeichenfolge. (Zum Test empfehle ich [http://www.mikrocontroller.net/topic/26477 HTerm] Zumindest die in Crossworks enthaltene Terminal Emulation arbeitet nicht korrekt, daher besser nicht verwenden)

Unter findet Ihr das Projekt zusammen mit einer CrossWorks Projektdatei [[Datei:ARM_USB_Test.zip]]. Voraussetzung zum Kompilieren ist folgende Verzeichnisstruktur
<syntaxhighlight lang="c">
Stammverzeichnis
|__ ARM_USB_Test
|
|__ ST_StandardLib ( Standard Peripheral Libary ab Libraries)
| |
| |__ CMSIS
| |
| |__ STM32F10x_StdPeriph_Driver
|
|___ ST_USB_LIB (STM32_USB-FS-Device_Lib ab Libraries)
|
|__ inc
|
|__ src
</syntaxhighlight>

=== Windows Treiber für den Virtual COM Port ===

Wie im Artikel [[Wieso braucht man überhaupt einen Treiber für einen Virtual Com port?]] diskutiert, läßt die Basiskonfiguration von Windows ziemlich zu wünschen übrig wenn es um Virtual COM Ports geht. Ohne ersichtlichen Grund wird diese Standardgeräteklasse nicht automatisch erkannt und unterstützt, sondern man benötigt einen passenden Treiber oder vielmehr die passen .inf-Datei.

Da die entsprechende kostenlose .inf-Datei auf der ST-Seite nicht so einfach zu finden ist, kann sie hier [[Datei:stmcdc.inf]] heruntergeladen werden.

Die STM32-CDC-Treiber sind WHQL Zertifiziert und über das Windows Update für die Versionen Windows 2000, XP (x86, x64), Vista (x86, x64) und 7 (x86, x64) erhältlich. Ansonsten kann der Treiber [https://my.st.com/public/STe2ecommunities/mcu/Lists/cortex_mx_stm32/DispForm.aspx?ID=18102&RootFolder=%2Fpublic%2FSTe2ecommunities%2Fmcu%2FLists%2Fcortex_mx_stm32%2FUsing%20STM32F10x%20USB%20device%20with%20Windows%20Vista%20or%20Windows%207 hier] heruntergeladen werden.

=== Schaltplan für diese Implementierung ===
[[Bild:STM32-USB-Schaltplan.png|thumb|Schaltplan]]
Für alle die die Schaltung nachbauen wollen hier der Schaltplan, der in meinem Lochrasteraufbau problemlos funktioniert. (Die SD-Card rechts hat natürlich nichts damit zu tun ;-)

== Aufbau der Beispielimplementierung==

Um die Implementierung einfacher nachvollziehen zu können, hier ein Archiv [[Bild:CrossWorks_StandardLib_Setup.zip]] mit einer kompletten Arbeitsumgebung für Crossworks.

Hier soll, wie ich Zeit dafür habe gezeigt werden welche der Funktionen und Dateien für uns interessant sind um eigene Funktionalität dort zu integrieren.

--[[Benutzer:Escamoteur|Escamoteur]] 07:39, 27. Apr. 2010 (UTC)

[[Kategorie:STM32]]
[[Kategorie:USB]]

STM32 USB-FS-Device Lib

2014-11-10T13:17:59Z

Kichi:

USB HID Host Treiber

2014-09-16T10:36:33Z

Kichi: /* Alternativen */

USB HID Schnittstellen für Steuerungsaufgaben zu verwenden ist allgemein üblich in der Elektronik. Es gibt unzählige Mikrocontroller mit USB von einer ganzen Menge Hersteller, welche die notwendige Firmware schon mitbringen. Aber auf PC Seite ist es immer noch mit einigem Aufwand verbunden, wenn man den USB nutzen will. Sparen Sie sich die Mühe und verwenden Sie die AHID Bibliothek.

===Funktionen===

* '''AHid_Init():''' initialisiert den Treiber.
* '''AHid_Register():''' registriert die Schnittstelle.
* '''AHid_Write():''' schreibt Daten.
* '''AHid_Read():''' ließt Daten ein.
* '''AHid_Request():''' fordert einen Feature Report an.
* '''AHid_Attached():''' stellt Anschluß an den USB fest.
* '''AHid_Find():''' sucht die Schnittstelle am Bus.
* '''AHid_Flush():''' löscht die Datenpuffer.
* '''AHid_Info():''' zeigt Treiber-Infos an.

===Konzept===

Die Bibliothek wird durch einmaligen Aufruf der Funktion AHid_Init() zu Beginn initialisiert. Mit AHid_Register() erhält man Zugriff auf das gewünschte USB-Gerät. Die Funktion öffnet eine Schnittstelle für den Datentransfer.

AHid_Write() dient zum Senden von Daten an das USB-Gerät. Hierbei wird ein Interrupt- oder Control-Transfer (Feature Report) verwendet (je nach Festlegung bei der Registrierung). Der Datenempfang erfolgt durch AHid_Read(). Bei Interrupt-Transfers wird hierfür ein eigener Thread gestartet, der fortlaufend die Schnittstelle auf ankommende Daten hin prüft. Sobald Daten vorliegen, wird an die Anwendung eine AHID_DATARECEIVED-Nachricht verschickt. Innerhalb der Nachrichtenschleife kann man dann auf diese Daten mit AHid_Read() zugreifen. Der Empfang von Feature Reports unterscheidet sich etwas von diesem Ablauf. Feature Reports müssen nämlich aktiv angefordert werden, was die Funktion AHid_Request() erledigt. Nach erfolgreichem Erhalt des Feature Reports wird wiederum eine AHID_DATARECEIVED-Nachricht verschickt und AHid_Read() erledigt dann den Rest. Durch dieses Konzept werden alle eingehenden Daten (unabhängig vom Transfertyp) an eine Stelle der Nachrichtenschleife transportiert. Das erleichtert das Erstellen einer Zustandsmaschine.

Die Funktion AHid_Attached() stellt fest, ob das USB-Gerät überhaupt am Bus verfügbar ist und gibt einen entsprechenden Wert zurück. AHid_Find() macht in etwa das Gleiche. Die Funktion sucht das USB-Gerät und gibt über den Rückgabewert den entsprechenden Zustand aus. Mit der Funktion AHid_Flush() werden die internen Datenpuffer gelöscht. Das kann notwendig sein, falls z.B. das USB-Gerät vom Bus abgeklemmt wird, und man noch nicht ausgelesene Daten sicher löschen möchte. AHid_Info() hat im normalen Betrieb keine Funktion. Es zeigt lediglich ein paar Informationen über die AHID Bibliothek an.

Die AHID Library ist eine '''Dynamic Link Library (DLL)''' und arbeitet mit verschiedenen Programmiersprachen zusammen. Sie steht als Download auf http://embedded24.net bereit.

Beispiel-Anwendungen:

* AHID Demo C++ (VS 2008)
* AHID Demo C# (VS 2010)
* AHID Demo VB (VS 2010)
* AHID Demo Matlab
* AHID Demo Scilab
* AHID Demo LabVIEW

===Download===

http://www.ahidlib.com

===Diskussion===

http://www.mikrocontroller.net/topic/210792

===Kontakt===

info(at)ahidlib.com

===Alternativen===
Zu obigem Treiber gibt es u.a. folgende Alternativen, deren Sourcen frei zugänglich sind:
* GenericHID von Jan Axelson ([http://www.janaxelson.com/hidpage.htm#MyExampleCode Link]) -> C++, C#, VB
* HidLibrary von Mike O'Brien ([https://github.com/mikeobrien/HidLibrary Link]) -> C#
* HidLibrary von jj-jabb ([https://github.com/jj-jabb/HidLibrary Link]) -> C# (Weiterentwicklung von Mike O'Briens Version)
* HidLib von jj-jabb ([https://github.com/jj-jabb/HidLib Link]) -> C#
* HID USB Library von Florian Leitner ([http://www.florian-leitner.de/index.php/2007/08/03/hid-usb-driver-library/#download Link]) -> C#
* Generic HID USB class-library von Simon Inns ([http://www.waitingforfriday.com/index.php/Open_Source_Framework_for_USB_Generic_HID_devices_based_on_the_PIC18F_and_Windows#Files_for_download Link]) -> C#
* USB HID Component von wimar ([http://www.codeproject.com/script/Articles/ViewDownloads.aspx?aid=18099 Link]) -> C#
* USBwisec von Bryan Batchelder ([http://sourceforge.net/projects/usbwisec/develop Link]) -> C#
* Raw HID von PJRC.COM ([http://www.pjrc.com/teensy/rawhid.html Link]) -> C
[[Kategorie:USB]]

Schaltungssimulation

2014-09-04T08:32:57Z

Kichi: Linkkorrektur

==Analog==
Für Analogsimulation und Mixed-Mode (Digital/Analog) ist Spice State-of-the-art. Spice ist inzwischen von vielen Herstellern erhältlich.

Siehe auch:
* [http://bwrc.eecs.berkeley.edu/classes/icbook/spice/ The Spice Page] des EECS Department of the University of California at Berkeley.

===PSpice===

http://www.orcad.com/products/orcad-ee-designer/overview
* http://www.flowcad.de/PSpice.htm (deutsche Produktbeschreibung vom Händler)
* nur für Windows
* kostenlos mit Größeneinschränkung
* Version 16.6 ist die aktuelle Version
* Einführungen
** http://www.flowcad.de/Schnellstart_PSpice_16_6.pdf
** http://people.fh-landshut.de/~wlf/Pspice/Einfuehrung/Einfuehrung.pdf
** http://www.elektronikschule.de/~krausg/ (links im Menü "Einstieg in PSpice leichtgemacht")
** [http://www.spicelab.de/index.htm Robert Heinemanns PSPICE-Seiten]

===GeckoCIRCUITS===

http://www.gecko-simulations.com

* Java-Basierter Schaltungssimulator, speziell für Leistungselektronik geeignet
* Veröffentlicht unter der Gnu Public License (Open-Source)
* Kostenlos
* Wahlweise ausführbar als Java-Applet (Online-Simulation) oder als Download
* Multi-Domain Simulation: Schaltung/Thermische Netzwerke/Regelungstechnik
* Kopplungsmöglichkeit zu Matlab/Simulink
* Skriptsteuerung möglich
* ideale Schalter, Verlustberechnung möglich
* Sehr einfach zu bedienen und anwenderfreundlich, extrem schnell

===Simplorer===

http://www.ansoft.com/downloads.cfm
*kostenlose Studentenversion
*Anmeldung erforderlich
*Besondere Eignung für Leistungselektronik
*Möglichkeit den Simulationsablauf durch Zustandsgraphen zu steuern
*Besonders einfache Möglichkeit Kennlinien zur Parametersteuerung zu verwenden
*Integration verschiedener physikalischer Domänen möglich (Mechanik, Hydraulik, Elektrik (...) )

Beispiel für die Leistungselektronik und Domänenübergriff: Mit den integrierten Mos-Fet Modellen (Level 1-3) wird eine B6 Brücke aufgebaut. Über die Zustandsgraphen kann eine
Raumzeigermodulation programmiert werden die über alpha-beta Koordinaten gesteuert
wird. Die Brücke steuert einen Asynchronmotor (Flussmodell) an diesem ist eine
Mechanische Last angeschlossen, z.B ein Feder-Dämpfer-System. Nun kann der Einfluss der Feder-Komponente auf die Zwischenkreisspannung analysiert werden.

Simplorer wird überwiegend im Mechatronischen Bereich eingesetzt. Die Studentenversion ist leider Stark eingeschränkt.

===LTspice/SwitcherCAD===
[[Datei:LTspice4-screenshot.png|miniatur|300px|Screenshot von LTspice IV]]
http://www.linear.com/designtools/software/#LTspice

* Kostenlos und beliebt

* Keinerlei Einschränkungen bezüglich Anzahl der Bauteile oder Knotenzahl

* SPICE-Simulator integriert unter einer graphischen Oberfläche zum Zeichnen von zu simulierenden Schaltungen

* Zum Einstieg empfehlenswert, da sehr übersichtlich. Erfordert allerdings mittelfristig detailliertere SPICE-Kenntnisse, da nicht alle SPICE-Funktionen hinter der graphischen Oberfläche versteckt sind.

* Das Programm heißt inzwischen offiziell LTspice IV. Man findet oft noch die älteren Bezeichnungen LTspice/SwitcherCAD, LTspice/SwitcherCAD III, SwitcherCAD/LTspice, SwCAD oder LTspice in älteren Unterlagen.

* Windows-Software (98, 2000, XP, Vista, 7), läuft mit WINE unter Linux

* Native Version für Mac OS X 10.7+ seit Ende 2013 erhältlich.

* Von einem Halbleiterhersteller ([http://www.linear.com/ Linear Technology]). Kommt daher mit einer großen Anzahl von Modellen für Linear Technology-Bauelemente und vielen Beispielen für diese. Darüber hinaus erlaubt LT die Verwendung als allgemeines Werkzeug zum Schaltplan-Zeichnen und zur SPICE-Simulation.
: Andere Halbleiterhersteller liefern normalerweise keine explizit für LTspice vorgesehenen oder getesteten Modelle, da sie logischerweise keinen Mitbewerber (Linear Technologies) unterstützen wollen. LTspice versteht jedoch normale SPICE-Modelle (.SUBCKT, .MODEL, usw.). Da LTspice weitgehend die SPICE-Erweiterungen von PSPICE versteht, können auch PSPICE-Modelle verwendet werden. Allerdings muss man eventuell, wie bei reinen SPICE-Textmodellen, ein eigenes Schaltzeichen-Symbol für das Bauteil erstellen (LTspice versteht diesen Teil von PSPICE nicht).

: '''Das Einbinden von Fremdmodellen''' wird im Handbuch / der Programm-Hilfe von LTspice erklärt. Jedoch nicht im Hauptteil, sondern versteckt '''im Kapitel ''FAQ''''', wo die Erklärungen gerne übersehen werden.

* Handbuch (entspricht der Programm-Hilfe): http://cds.linear.com/docs/ltspice/LTspiceHelp.chm

* Kleine Einführung: http://www.ee.hm.edu/fk/lab/lst/spice/LTSpiceInfo.pdf

* Längere, empfehlenswerte Einführung und zugehörige Beispielschaltungen: http://highered.mcgraw-hill.com/sites/0073106941/student_view0/lt_spice_instructions_and_support_files.html

* International User Group: http://groups.yahoo.com/group/LTspice/
: Die User Group erfordert eine Anmeldung bei Yahoo und eine Zulassung zur Gruppe.

: Eine Liste von Bauteilen, die aus verschiedenen Quellen stammen, ist nach Anmeldung in der obigen User Group zu bekommen. Dort gibt es auch die Modelle zum Download. Die erste Anlaufquelle, um häufig eingesetzte Bauteile zu finden.

: Die Diskussion undokumentierter Befehle und Modelle sowie die Untersuchung der internen Funktionsweise wird konsequent unterbunden.

* Eine Menge Modelle und eine gute Einführung http://www.elektronikschule.de/~krausg/

* [http://ltwiki.org/index.php5?title=Main_Page LT Wiki Tipps, Tricks, undokumentierte Befehle] (englisch)

* Regelungstechnik-Modelle http://home.scarlet.be/nap0/ltspice/

===SIMetrix===
Größeneinschränkung
ab Win 2000 und teilw. Linux
http://www.catena.uk.com/site/downloads/SIMetrixIntro.htm

===ngSpice===

http://ngspice.sourceforge.net/
* Open Source (BSD-Lizenz)
* Kommandozeilenorientiert, mit graphischer Ausgabe
* Erweitert Berkeley spice3f5 [http://ngspice.sourceforge.net/extras.html um viele zusätzliche Möglichkeiten]
* für Linux, Windows, MacOS
* integriert XSPICE, daher auch für Mixed-Signal-Simulation geeignet
* eigene XSPICE code models können erstellt werden
* integriert TclSpice, eine tcl/tk-Schnittstelle
* ausführliches Manual mit Einführung, Beipielen und allen aktuellen Features unter http://ngspice.sourceforge.net/docs/ngspice-manual.pdf
* Anleitung für gEDA und Spice http://www.brorson.com/gEDA/SPICE/t1.html
* [http://sourceforge.net/projects/gspiceui/ GSpiceUI - A graphic interface for SPICE] (Linux)

===TCLSpice===

http://tclspice.sourceforge.net/

* TclSpice ist eine verbesserte Version von Berkeley Spice und benutzt die Tcl/Tk Skript Sprache.
* open-source (BSD Lizenz) basierend auf NG-Spice Quellcode

===NI MultiSim / Electronics Workbench===

http://www.ni.com/multisim/
http://www.electronicsworkbench.com/edu/eduhom.html

* Electronics Workbench wurde von National Instruments aufgekauft. In NIs MultiSim aufgegangen.
* 30-Tage Testversionen erhältlich
* nur für Windows
* Ab Wine 1.0 und bis MultiSim 9 auch auf Linux lauffähig
* [http://www.analog.com/en/content/CU_multisim_SPICE_program_download/fca.html eine freie Version wird von Analog Devices angeboten]

===Tina===
http://www.tina.com/
* sehr eingeschränkte Demo-Version (PCB Layout nur mit weniger als 50 Pads erlaubt)
* [http://focus.ti.com/docs/toolsw/folders/print/tina-ti.html Tina-TI Version von Texas Instrument] ähnlich dem LTSpice von Linear Technology, ebenfalls kostenlos

===Gnucap===
* http://www.geda.seul.org/tools/gnucap/
* [http://sourceforge.net/projects/gspiceui/ GSpiceUI - A graphic interface] (Linux)

===qucs===
http://qucs.sourceforge.net/
* freie Software
* für Linux, Windows, OS X
* viele Modelle aus dem HF-Bereich

=== lcfilter ===
http://www-users.cs.york.ac.uk/~fisher/lcfilter/
Online-Filterberechnung L-C-Filter

=== eispice ===

http://www.thedigitalmachine.net/eispice.html

SPICE ähnlicher Schaltungssimulator mit Python Interface

=== Yenka Analogue Electronics ===

[http://www.yenka.com/ Yenka] is a simulator for designing circuits using analogue electronic components. Mac OS X or Windows XP/Vista. You can use all Yenka products free of charge at home.

=== Solve Elec ===

With [http://www.physicsbox.com/indexsolveelec2en.html Solve Elec] you can:
* draw and analyze electrical circuits functioning in direct or alternating current
* get literal formulas and values for current intensities and voltages defined in the circuit.
* verify circuit related equations.
* draw graphs.
* get the equivalent circuit of displayed circuit
* browse an integrated documentation
* edit, save and print reports made of various elements displayed in main window
(MacOSX, Windows, Free)

===PLECS===

http://www.plexim.com/de/plecs

* Die Simulationsplattform für leistungselektronische Systeme
* als MATLAB Toolbox und Standalone erhältlich
* freie Version je nach Universität erhältlich
* 30 Tage Testversion erhältnlich
* Schaltung mit elektrischer, magnetischer, mechanischer und thermischer Domain

==Digital==

===Simulo===
http://www.codeplex.com/simulo
* Simple and modern digital simulation program. It's based upon .NET Framework 3.5 SP1 and WPF.

===DigitalSimulator===
http://www.draw2d.org/digitalsimulator/
* Windows und Online Browser Variante verfügbar

=== HADES ===
http://tams-www.informatik.uni-hamburg.de/applets/hades/html/index.html
* betriebssystemunabhängig (Java)

=== mkfilter ===
http://www-users.cs.york.ac.uk/~fisher/mkfilter/
Online-Digitalfilterberechnung FIR, IIR

=== edef ===
[http://edef.sourceforge.net/ edef] - A simple discrete event simulation. The edef framework can be used to simulate typical logical circuits, autoregressive processes or digital controller circuits and maybe some more. It is designed to be simple enougth for use in schools or other educational context. It is also truly easy to extend.

=== TkGate ===
[http://www.tkgate.org/ TkGate] is a event driven digital circuit simulator with a tcl/tk-based graphical editor. (GPL)

=== Atanua ===

[http://atanua.org/ Atanua ] is a real-time logic simulator, designed to help in learning of basic boolean logic and electronics. It uses OpenGL hardware-accelerated rendering and a custom UI designed for a fast workflow and a very low learning curve, letting the students concentrate on learning the subject instead of spending time learning the tool. (Personal non-commercial license: Free. Andere Nutzungen: siehe Webseite)

=== MMLogic ===

[http://www.softronix.com/logic.html MMLogic] is a MultiMedia Logic Design System for Windows (NT/2K/Xp/95/98/ME, now Freeware)

=== WireItUp ===

[http://www.wireitup.de WireItUp] is a Digital Logic Simulator especially made for educational purposes.(Windows 8/7/Vista/XP, Freeware)

=== Yenka Digital Electronics ===

[http://www.yenka.com/ Yenka] is a simulator for designing circuits using digital 4000 and 7400 series electronic components. Mac OS X or Windows XP/Vista. You can use all Yenka products free of charge at home.

=== KSimus ===

[http://ksimus.berlios.de/ KSimus] is a simulator for KDE.

=== Digital Simulator ===

[http://www.mit.edu/~ara/ds.html Digital Simulator] has a toolbar of digital circuit elements, including logic gates, flip-flops, switches, and indicators. Drawing a circuit with Digital Simulator is like using a paint program. You click the element's icon on the toolbar, then click where you want the element to go. You use a similar procedure to draw wires and indicate connections. It's that simple. Free for educational institutions or students. (Windows 3.1, 95/NT)

=== KLogic ===

[http://www.a-rostin.de/indexd.html KLogic] ist eine Anwendung zum einfachen Entwurf und zur Simulation von Digitalschaltungen. KLogic ermöglicht einen einfachen Aufbau von Schaltungen aus Standardkomponenten wie UND, ODER, XOR, und Flipflops wie RS und JK. Um komplexere und wiederverwendbare Schaltungen zu entwerfen, können Teilschaltungen gespeichert und wiederverwendet werden. (Linux, GPL)
Die letzte Version stammt aus dem Jahr 2006 und läuft leider recht instabil. Es gibt mittlerweile jede Menge grafisch unschöne Stellen und, schlimmer noch, auch diverse Bugs, die einen Crash verursachen.

=== Logic Simulator ===

With [http://www.tetzl.de/java_logic_simulator.html LogicSim] you can design and simulate digital logic circuits with logic gates like AND, OR, FlipFlop, etc.

=== HS-FIR-Compiler ===
[http://www.steepestascent.com/content/default.asp?page=s2_22 steepestascent.com]
14 day evaluation license:
The High Speed FIR Filter Compiler is a standalone utility that automatically generates VHDL code for fast and efficient FIR filters and is ideal for both FPGA and ASIC implementation.

=== Interactive 595 Shift Register Simulator ===

[http://conductiveresistance.com/interactive-595-shift-register-simulator/ Interactive 595 Shift Register Simulator]

=== Logic Circuit ===

[http://www.logiccircuit.org/ Logic Circuit] is free, open source educational software for designing and simulating digital logic circuits. Intuitive graphical user interface, allows you to create unrestricted circuit hierarchy with multi bit buses, debug circuits behavior with oscilloscope, and navigate running circuits hierarchy. (GPLv2, Windows: .NET 4.0 erforderlich)

== Mixed Analog-Digital ==

===SPECTRE===

Der [http://www.cadence.com/products/rf/spectre_circuit/pages/default.aspx Cadence Virtuoso Spectre Circuit Simulator] ist ein Mixed AD-Simulator auf der Basis von Spice. (Kommerziell)

===HSPICE===

[http://www.synopsys.com/Tools/Verification/AMSVerification/CircuitSimulation/HSPICE/Pages/default.aspx HSPICE] ist ein PSpice-ähnlicher Simulator, der sowohl ABM-Modelle, als auch eigens erstellte library-Modelle verarbeiten kann. (Kommerziell)

===XSPICE===
http://users.ece.gatech.edu/~mrichard/Xspice/

===ngSpice===

http://ngspice.sourceforge.net/
* Open Source (BSD-Lizenz)
* Kommandozeilenorientiert, mit graphischer Ausgabe
* Erweitert Berkeley spice3f5 [http://ngspice.sourceforge.net/extras.html um viele zusätzliche Möglichkeiten]
* für Linux, Windows, MacOS
* integriert XSPICE, daher auch für Mixed-Signal-Simulation geeignet
* eigene XSPICE code models können erstellt werden
* ausführliches Manual mit Einführung, Beipielen und allen aktuellen Features unter http://ngspice.sourceforge.net/docs/ngspice-manual.pdf

=== SMASH from DOLPHIN INTEGRATION ===
http://www.dolphin.fr/index.php/eda_solutions/products/smash/overview
* SMASH from Dolphin Integration is a mixed-signal, multi-language simulator for IP and IC designs. It uses [[SPICE]] syntax for analog descriptions, [[Verilog]]-HDL and [[VHDL]] for digital, Verilog-A/AMS, VHDL-AMS and ABCD (a combination of SPICE and C) for analog behavioral, and C for [[DSP]] algorithms.
* Logik, Analog und Mixed-Simulation
* Für Linux und Windows
* Engeschränkte Evaluationsversion erhältlich

===Micro-Cap===

http://www.spectrum-soft.com
* nur für Windows
* Evaluation Version (mit Einschränkungen) nach Registrierung erhältlich

===GNU-Radio===
http://gnuradio.org/redmine/wiki/gnuradio
GNU Radio is a free software development toolkit that provides the signal processing runtime and processing blocks to implement software radios using readily-available, low-cost external RF hardware and commodity processors. It is widely used in hobbyist, academic and commercial environments to support wireless communications research as well as to implement real-world radio systems.

=== Oregano ===

http://oregano.gforge.lug.fi.uba.ar/

Beschreibung von [http://elettrolinux.com/Simulations/oregano-an-electrical-tool.html elettrolinux.com]:

'''Oregano''' is a LINUX application for schematic capture and simulation of electronic circuits. Oregano has an user friendly graphic interface that allows to design and describe the circuit to simulate. It provides a wide variety of component libraries, including CMOS, TTL, lineal, operational amplifiers, and a lot more! Oregano lets you simulate the designed circuits. The actual simulation is performed by Berkeley Spice BSIM, GnuCAP or the new generation NGSpice. Oregano is licensed under the terms of the GNU GPL.

=== VirtualBreadboard ===

[http://www.virtualbreadboard.com/ VirtualBreadboard] is an easy to use simulation and modelling tool that can be used in place of a real breadboard for quickly performing experiments and testing out electronic and microcontroller ([[PIC]]) powered 'embedded' applications. (Seit Version 3.3.12 11 July 2009 Freeware, Windows)

=== BasicDSP ===
[http://www.vf.utwente.nl/~ptdeboer/ham/basicdsp/ von Pieter-Tjerk de Boer, PA3FWM, und Niels Moseley, PE1OIT]
A program for experimenting with simple audio DSP algorithms

===LTspice/SwitcherCAD===
http://www.linear.com/designtools/software/#LTspice

Hauptsächlich für die Simulation analoger Schaltungen verwendet, enthält LTspice doch einig digitale Grundfunktionen. Diese sind nur zum Teil im Handbuch als A-Schaltungselemente (''Circuit Elements'' --> ''A. Special Functions'') beschrieben.

==Hochfrequenztechnik==

=== Linksammlungen ===

* [http://www.circuitsage.com/tline.html Transmission Line Design and Analysis]
* [http://www.mwrf.com/Articles/Print.cfm?ArticleID=22572 Übersichtsartikel der Microwave & RF] [http://www.mwrf.com/Articles/Print.cfm?ArticleID=22809 und hier]

=== Ansoft ===
*Maxwell SV: Simulation von elektrischen und magnetischen Feldern (2D)
*Simplorer SV: Schaltungssimulation
*PExprt SV: Berechung von Schaltnetzteilen

Wurde 2008 von [http://www.ansys.com/ Ansys] gekauft,
http://www.ansys.com/Products/Simulation+Technology/Electromagnetics

die kostenlose Studentenversion "Ansoft Designer" gibts nur noch von G.Kraus:
http://www.gunthard-kraus.de
[http://www.gunthard-kraus.de/Ansoft%20Designer%20SV/DesignerSV050610.exe Download exe-File]
=== ARRL Radio Designer ===
für 169€ bei http://www.ukw-berichte.de erhältlich http://www.arrl.org
* Amateurversion der amerikanischen Design-Software Super Compact.
* Mittlerweile durch Ansoft Designer (ehem. Ansoft Serenade) überholt

=== AADE Filter Design ===
Homepage: http://www.aade.com/filter.htm

kostenlose Analog-Filterberechnung:
* Butterworth, Chebyshev, Elliptic (Cauer), Bessel, Legendre and Linear Phase
* low-pass, high-pass, band-Pass, and band-reject filters.
* Coupled Resonator band-pass filters
* Crystal Ladder band-pass filters using identical crystals

=== ActiveFilterDesign ===
Active Filter Design für Matlab, kostenloser Download: http://academics.vmi.edu/ee_js/Research/Programs/materials/AFD12.zip

Handbuch: http://academics.vmi.edu/ee_js/Research/Programs/materials/Analog%20Filter%20Designer.pdf

* FIR, IIR, analoge Filter, Synthese und Analyse

=== atlc - Arbitrary Transmission Line Calculator ===

* freie Software (Gnu General Public License)

Übertragungsleitungen (und eingeschlossen Richtkoppler) können mit der Open Source Software auf ihre Impedanz, aber nicht ihre Dämpfung berechnet werden.
Dabei ist die Form und Anordnung der Leiter und Dielektrica beliebig, aber die Anzahl der Leiter ist auf maximal Drei beschränkt. Es können keine Hohlleiter berechnet werden. Die üblichen Anordnungen auf Leiterplatten werden aber abgedeckt. Es wird eine Bitmap erstellt, die geometrischen und elektrischen Eigenschaften des Leitungsquerschnits als Farbe codiert enthält. Diese Bitmap wird dann vom Programm bearbeitet. Die Methode, die das Programm benutzt, ist die der [http://de.wikipedia.org/wiki/Finite-Differenzen-Methode finiten Differenzen]. Autor des Programmes ist Dr. David Kirkby alias G8WRB.
Das Programm ist in den meisten gängigen Linux Distributionen als Package erhältlich. Die Homepage mit Anleitungen, FAQ und Beispielen findet sich hier:
http://atlc.sourceforge.net/

=== AWR ===
http://web.awrcorp.com/

free trial versions erhältlich für:
* ANALOG OFFICE - High-Frequency Design Software for Analog and RFICs
* APLAC - Harmonic balance simulation engine
* AXIEM - 3D Planar Electromagnetic Software for Antennas and Passives
* MICROWAVE OFFICE - RF and Microwave Design Software for MMIC, RF PCB and Modules
* VISUAL SYSTEM SIMULATOR - Wireless Communication System Design Software

* TxLine [http://web.awrcorp.com/Usa/Products/Optional-Products/TX-Line/ free Transmission Line Calculator]

=== CST STUDIO SUITE™ ===
http://www.cst.com/

...deckt alles ab, 3D-EM Simulation für elektrostatische Probleme bis Hochfrequenz, Zeit- und Frequenzbereich, Fernfelder, EMV, Spice-Ersatzmodelle, PCBs, Partikelsimulation, Co-Simulation mit thermischen und mechanischen Problemen, Raytraycing.

=== Elsie ===
http://www.tonnesoftware.com/elsie.html
a Windows electrical filter design and analysis program handling all of the usual options (family, topology, bandwidth, etc.). It has a nice toolbox including real-time tuning modes and optimization. Outputs are presentation quality. Student edition is free.

=== FastHenry ===
Windowsversion http://www.fastfieldsolvers.com/

* open source
* Impedanzextraktion (R und L) aus 3D-Geometrieen
* Erfasst Skin-, Proximity-Effekte, magnetische Kopplungseffekte
* Erstellung von Spice-Modellen möglich

=== FilterFree ===
http://www.nuhertz.com/filter/

Filter Free is the free version of Filter Solutions and Filter Light. Functionality is limited 3rd order analog and IIR filters, and 10 tap FIR filters. Filters are synthesized. Frequency, time, and reflection analysis are performed on the ideal, unmodified filters only. Transfer functions are displayed in standard form only.

=== HP AppCAD ===
http://www.hp.woodshot.com/

RF design software is provided free of charge by Agilent Technologies
as a service to the RF and microwave design community

Läuft unter Windows ab 95c/NT4

=== Nova.exe ===
http://www.pcb-pool.com/ppde/service_downloads.html

NOVA is a program that can be used to analyze most linear (AC) circuits. It
can calculate voltage, phase, and delay at any circuit point (node) at any
frequencies. Most (AC) circuit analysis programs can only give useful results
for low frequencies (below 10 Mhz). NOVA can do this but it can also be used
for RF and microwave circuits. Microwave circuits require the analysis be done
in terms of S-parameters, rather then AC voltages. NOVA does AC, time domain,
and S-parameter analysis.This version of NOVA has circuit tweaking while in the graph mode. You may find it extremely useful. Vary a component and watch the response, return loss, and delay change.

Gutes altes DOS-Programm, AC- oder S-Parameter-Darstellung.
Ausdruck unter WinXP nur mit Screenshot-Programm möglich, getestet z. B. mit Snarf15: http://www.idcomm.com/personal/lorenblaney/SNARF15.ZIP

=== PUFF - Microwave Design Software ===
für 22€ bei http://www.ukw-berichte.de/ erhältlich
* altes DOS-Programm für HF-Simulation und Platinenentwurf
* Microstrip HF-Berechnungen, Smith-Diagramm
* in den UKW-Berichten standen schon mehrere Artikel mit Beispielen
* zur Nutzung einer Kombination aus PUFF und Ansoft SV (=Studentenversion)

Seit Anfang 2010 wird PUFF unter der GPLv3 License geführt. Der Pascal Quelltext mit Linux Package und Handbuch ist frei verfügbar. [http://wwwhome.cs.utwente.nl/~ptdeboer/ham/puff/ PUFF microwave CAD software on Linux]

=== RF-Sim 99 ===
kostenlos z. B. von: http://www.janson-soft.de/amateurfunk/rfsim99/rfsim99.htm

oder neben anderen PDFs zur HF-Technik: http://home.sandiego.edu/~ekim/e194rfs01/
* Berechnung aktiver und passiver Filter einschließlich Schaltplaneingabe
* Ausgabe von Frequenz- und Phasengang, Smith-Diagramm

=== Smith Plot ===
Neben diversen Mathcad-Beispielen und Skripten aus der HF-Technik eine Smith-Chart-Software:
http://www.fritz.dellsperger.net/downloads.htm

=== Sonnet Lite ===
Sonnet Lite provides a full-wave EM solution for 3D planar circuits
A fully functional and powerful EM analysis software.
Get started on your EM analysis within the next 30 minutes by downloading SONNET Lite!
http://www.sonnetsoftware.com/products/lite/
http://www.sonnetsoftware.com/

===qucs===
http://qucs.sourceforge.net/
* freie Software
* für Linux, Windows, OS X
* hervorragende technische Dokumentation
* Impedanzrechenfunktionen für Strip- und Microstripleitungen
* Filterberechnungstool

===ADS (Advanced Design System)===
http://www.home.agilent.com/en/pc-1297113/advanced-design-system-ads?&cc=DE&lc=ger

http://de.wikipedia.org/wiki/Advanced_Design_System

Advanced Design System, kurz ADS, ist eine spezielle Simulationssoftware der Firma Agilent zur Simulation von elektrischen Schaltungen für die Hochfrequenztechnik und stellt in diesem Segment einen Industriestandard dar.

==Antennensimulation==

=== cocoaNEC ===
Homepage: http://homepage.mac.com/chen/w7ay/cocoaNEC/index.html
* Design und modulierung von Antennen
* MacOS X (PowerPC und Intel)
* Frei erhältlich (mit Quellcode)

=== EZ-NEC ===
Homepage: http://eznec.com/
* Antennenberechnung
demo program allows only 20 segments, which limits the complexity of antenna
you can analyze. (EZNEC 4.0 allows 500 )

=== MiniNEC ===
Homepage: http://www.emsci.com/ '''(2013-05-01 Seite nicht mehr vorhanden)'''
* Antennenberechnung mittels "Momentenmethode" (Zerlegung der Antenne in kleine Segmente, Überlagerung der Teilfelder)
* eingeschränkte Studenten/Amateurversion erhältlich
* NEC = Numerical Electromagnetics Code

=== SuperNEC ===
Homepage: http://www.supernec.com/
* Antennenberechnung mittels "Momentenmethode"
* 30-Tage-Testversion sowie unbegrenzt lauffähige Studentenversion (gegen Nachweis) erhältlich

=== MMANA ===
Homepage (deutsche Version) : http://dl2kq.de/mmana/4-7.htm

Kostenlose Antennen-Analysesoftware, auf der mit MININEC Version 3 eingeführten Momentenmethode basierend

=== RadioMobile ===
Hochfrequenz-Ausbreitungssimulation
* [http://www.cplus.org/rmw/english1.html Hauptseite]
* [http://www.cplus.org/rmw/rme.html Beispielbilder]
* [http://www.cplus.org/rmw/dataen.html dazu erforderliche Kartendaten]
* [http://de.wikipedia.org/wiki/SRTM-Daten Wikipedia zum SRTM-Kartendatenformat]

== Sonstige ==

=== FEMM ===
* [http://www.femm.info/wiki/HomePage Finite Element Method Magnetics] (FEMM)

=== GALEMU ===

[http://bu3sch.de/joomla/index.php/galpal-emulator Galemu] is a [[GAL]]/[[PAL]] chip emulator. (GPL)

==Numerische Berechnungswerkzeuge==

===Derive===
http://education.ti.com

===FreeMat===
http://freemat.sourceforge.net
* freier MatLab-Clone
* für Windows, Linux, Mac OS X

===GAUSS===
Wissenschaftliche Simulationssoftware zur Berechung 3-dimensionaler Ladungsverteilungen in z. B. Halbleitern. Kann aus Geometrie und Dotierungsprofilen die Halbleitergleichungen ableiten.

===GnuPlot===
http://www.gnuplot.info/
* freie Software
* für Linux, Windows und weitere
* sehr mächtiges Tool, aber eher im Bereich der Datenauswertung (Diagramme)
* [http://ttsiodras.googlepages.com/gnuplotStreaming.html Visualize real-time data streams with Gnuplot] (Perl)

===Maple===
http://www.maplesoft.com/
* Wissenschaftliche Analyse und Simulationssystem zur Lösung komplexester Aufgaben der Mathematik. Lizenzpflichtig.

===JMathLib===
http://mathlib.sourceforge.net
* freier Matlab-Clone in 100% Java
* für Windows, Linux, ...

===MatLab===
http://www.mathworks.com/

===MuPad===
http://www.mupad.de/

===Mathcad===
http://www.mathsoft.com/ http://www.ptc.com/appserver/mkt/products/home.jsp?k=3901
* rechnen mit Formeln wie auf dem Papier

===Maxima===
http://maxima.sourceforge.net/
* freie Software für Linux, OSX, Windows

===Octave===
http://www.octave.org/
* freier MatLab-Clone. Die Syntax ist überwiegend identisch
* für Linux, Windows, OSX

===GNU R===
http://www.r-project.org/
* freier S-Clone. Die Syntax ist überwiegend identisch
* für Linux, Windows, OSX

===SciLab===
http://www.scilab.org/
* freie Software
* für Linux, Windows, MacOS
* stellt eine C++ Library bereit, die in eigene DSP-Systeme eingebunden werden kann

===scipy===
scipy [http://www.scipy.org/] ist eine Erweiterung der Skriptsprache Python [http://www.python.org] mit numerischen Funktionen
* freie Software
* für Linux, Windows, OSX

===SMathStudio===
SMathStudio [http://www.smathstudio.com/] ist ein an MathCad angelehntes numerischer Berechnungs-, Visualisierungs-, und Dokumentationstool. Die Software ist Freeware/Donationware. Sie ist ins deutsche übersetzt, wird derzeit (Stand 26.06.2012) aktiv weiterentwickelt und supported im eigenem Forum

== Online Schaltungssimulatoren ==

* [http://www.mikrocontroller.net/topic/79658#664688 Diskussion im Forum]
* http://www.falstad.com/circuit/
* [http://www.intersil.com/isim/ Intersil’s iSim]
* [http://smile.hsu-hh.de/Schaltungen/Index.htm WSPICE] (fixe Schaltungen)
* [http://micropci1.imtek.uni-freiburg.de/svs/ spicy VOLTsim]
* [http://www.gecko-simulations.com/geckocircuits.html GeckoCIRCUITS]
* [https://www.circuitlab.com CircuitLab]
* [http://www.poweresim.com/ PowerEsim] - Free SMPS Switching Power Supply / Transformer Design Software

== Tutorials ==

* [http://www.elektronikschule.de/~krausg/ Elektronikschule.de von Gunthard Kraus] (ORCAD-PSPICE, LTspice IV)

[[Kategorie:Entwicklungstools]]
[[Kategorie:Schaltplaneditoren]]

Schaltungssimulation

2014-09-04T08:32:11Z

Kichi: Links korrigert

==Analog==
Für Analogsimulation und Mixed-Mode (Digital/Analog) ist Spice State-of-the-art. Spice ist inzwischen von vielen Herstellern erhältlich.

Siehe auch:
* [http://bwrc.eecs.berkeley.edu/classes/icbook/spice/ The Spice Page] des EECS Department of the University of California at Berkeley.

===PSpice===

http://www.orcad.com/products/orcad-ee-designer/overview
* http://www.flowcad.de/PSpice.htm (deutsche Produktbeschreibung vom Händler)
* nur für Windows
* kostenlos mit Größeneinschränkung
* Version 16.6 ist die aktuelle Version
* Einführungen
** http://www.flowcad.de/Schnellstart_PSpice_16_6.pdf
** http://people.fh-landshut.de/~wlf/Pspice/Einfuehrung/Einfuehrung.pdf
** http://www.elektronikschule.de/~krausg/ (links im Menü "Einstieg in PSpice leichtgemacht")
** [http://www.spicelab.de/index.htm Robert Heinemanns PSPICE-Seiten]

===GeckoCIRCUITS===

http://www.gecko-simulations.com

* Java-Basierter Schaltungssimulator, speziell für Leistungselektronik geeignet
* Veröffentlicht unter der Gnu Public License (Open-Source)
* Kostenlos
* Wahlweise ausführbar als Java-Applet (Online-Simulation) oder als Download
* Multi-Domain Simulation: Schaltung/Thermische Netzwerke/Regelungstechnik
* Kopplungsmöglichkeit zu Matlab/Simulink
* Skriptsteuerung möglich
* ideale Schalter, Verlustberechnung möglich
* Sehr einfach zu bedienen und anwenderfreundlich, extrem schnell

===Simplorer===

http://www.ansoft.com/downloads.cfm
*kostenlose Studentenversion
*Anmeldung erforderlich
*Besondere Eignung für Leistungselektronik
*Möglichkeit den Simulationsablauf durch Zustandsgraphen zu steuern
*Besonders einfache Möglichkeit Kennlinien zur Parametersteuerung zu verwenden
*Integration verschiedener physikalischer Domänen möglich (Mechanik, Hydraulik, Elektrik (...) )

Beispiel für die Leistungselektronik und Domänenübergriff: Mit den integrierten Mos-Fet Modellen (Level 1-3) wird eine B6 Brücke aufgebaut. Über die Zustandsgraphen kann eine
Raumzeigermodulation programmiert werden die über alpha-beta Koordinaten gesteuert
wird. Die Brücke steuert einen Asynchronmotor (Flussmodell) an diesem ist eine
Mechanische Last angeschlossen, z.B ein Feder-Dämpfer-System. Nun kann der Einfluss der Feder-Komponente auf die Zwischenkreisspannung analysiert werden.

Simplorer wird überwiegend im Mechatronischen Bereich eingesetzt. Die Studentenversion ist leider Stark eingeschränkt.

===LTspice/SwitcherCAD===
[[Datei:LTspice4-screenshot.png|miniatur|300px|Screenshot von LTspice IV]]
http://www.linear.com/designtools/software/#LTspice

* Kostenlos und beliebt

* Keinerlei Einschränkungen bezüglich Anzahl der Bauteile oder Knotenzahl

* SPICE-Simulator integriert unter einer graphischen Oberfläche zum Zeichnen von zu simulierenden Schaltungen

* Zum Einstieg empfehlenswert, da sehr übersichtlich. Erfordert allerdings mittelfristig detailliertere SPICE-Kenntnisse, da nicht alle SPICE-Funktionen hinter der graphischen Oberfläche versteckt sind.

* Das Programm heißt inzwischen offiziell LTspice IV. Man findet oft noch die älteren Bezeichnungen LTspice/SwitcherCAD, LTspice/SwitcherCAD III, SwitcherCAD/LTspice, SwCAD oder LTspice in älteren Unterlagen.

* Windows-Software (98, 2000, XP, Vista, 7), läuft mit WINE unter Linux

* Native Version für Mac OS X 10.7+ seit Ende 2013 erhältlich.

* Von einem Halbleiterhersteller ([http://www.linear.com/ Linear Technology]). Kommt daher mit einer großen Anzahl von Modellen für Linear Technology-Bauelemente und vielen Beispielen für diese. Darüber hinaus erlaubt LT die Verwendung als allgemeines Werkzeug zum Schaltplan-Zeichnen und zur SPICE-Simulation.
: Andere Halbleiterhersteller liefern normalerweise keine explizit für LTspice vorgesehenen oder getesteten Modelle, da sie logischerweise keinen Mitbewerber (Linear Technologies) unterstützen wollen. LTspice versteht jedoch normale SPICE-Modelle (.SUBCKT, .MODEL, usw.). Da LTspice weitgehend die SPICE-Erweiterungen von PSPICE versteht, können auch PSPICE-Modelle verwendet werden. Allerdings muss man eventuell, wie bei reinen SPICE-Textmodellen, ein eigenes Schaltzeichen-Symbol für das Bauteil erstellen (LTspice versteht diesen Teil von PSPICE nicht).

: '''Das Einbinden von Fremdmodellen''' wird im Handbuch / der Programm-Hilfe von LTspice erklärt. Jedoch nicht im Hauptteil, sondern versteckt '''im Kapitel ''FAQ''''', wo die Erklärungen gerne übersehen werden.

* Handbuch (entspricht der Programm-Hilfe): http://cds.linear.com/docs/ltspice/LTspiceHelp.chm

* Kleine Einführung: http://www.ee.hm.edu/fk/lab/lst/spice/LTSpiceInfo.pdf

* Längere, empfehlenswerte Einführung und zugehörige Beispielschaltungen: http://highered.mcgraw-hill.com/sites/0073106941/student_view0/lt_spice_instructions_and_support_files.html

* International User Group: http://groups.yahoo.com/group/LTspice/
: Die User Group erfordert eine Anmeldung bei Yahoo und eine Zulassung zur Gruppe.

: Eine Liste von Bauteilen, die aus verschiedenen Quellen stammen, ist nach Anmeldung in der obigen User Group zu bekommen. Dort gibt es auch die Modelle zum Download. Die erste Anlaufquelle, um häufig eingesetzte Bauteile zu finden.

: Die Diskussion undokumentierter Befehle und Modelle sowie die Untersuchung der internen Funktionsweise wird konsequent unterbunden.

* Eine Menge Modelle und eine gute Einführung http://www.elektronikschule.de/~krausg/

* [http://ltwiki.org/index.php5?title=Main_Page LT Wiki Tipps, Tricks, undokumentierte Befehle] (englisch)

* Regelungstechnik-Modelle http://home.scarlet.be/nap0/ltspice/

===SIMetrix===
Größeneinschränkung
ab Win 2000 und teilw. Linux
http://www.catena.uk.com/site/downloads/SIMetrixIntro.htm

===ngSpice===

http://ngspice.sourceforge.net/
* Open Source (BSD-Lizenz)
* Kommandozeilenorientiert, mit graphischer Ausgabe
* Erweitert Berkeley spice3f5 [http://ngspice.sourceforge.net/extras.html um viele zusätzliche Möglichkeiten]
* für Linux, Windows, MacOS
* integriert XSPICE, daher auch für Mixed-Signal-Simulation geeignet
* eigene XSPICE code models können erstellt werden
* integriert TclSpice, eine tcl/tk-Schnittstelle
* ausführliches Manual mit Einführung, Beipielen und allen aktuellen Features unter http://ngspice.sourceforge.net/docs/ngspice-manual.pdf
* Anleitung für gEDA und Spice http://www.brorson.com/gEDA/SPICE/t1.html
* [http://sourceforge.net/projects/gspiceui/ GSpiceUI - A graphic interface for SPICE] (Linux)

===TCLSpice===

http://tclspice.sourceforge.net/

* TclSpice ist eine verbesserte Version von Berkeley Spice und benutzt die Tcl/Tk Skript Sprache.
* open-source (BSD Lizenz) basierend auf NG-Spice Quellcode

===NI MultiSim / Electronics Workbench===

http://www.ni.com/multisim/
http://www.electronicsworkbench.com/edu/eduhom.html

* Electronics Workbench wurde von National Instruments aufgekauft. In NIs MultiSim aufgegangen.
* 30-Tage Testversionen erhältlich
* nur für Windows
* Ab Wine 1.0 und bis MultiSim 9 auch auf Linux lauffähig
* [http://www.analog.com/en/content/CU_multisim_SPICE_program_download/fca.html eine freie Version wird von Analog Devices angeboten]

===Tina===
http://www.tina.com/
* sehr eingeschränkte Demo-Version (PCB Layout nur mit weniger als 50 Pads erlaubt)
* [http://focus.ti.com/docs/toolsw/folders/print/tina-ti.html Tina-TI Version von Texas Instrument] ähnlich dem LTSpice von Linear Technology, ebenfalls kostenlos

===Gnucap===
* http://www.geda.seul.org/tools/gnucap/
* [http://sourceforge.net/projects/gspiceui/ GSpiceUI - A graphic interface] (Linux)

===qucs===
http://qucs.sourceforge.net/
* freie Software
* für Linux, Windows, OS X
* viele Modelle aus dem HF-Bereich

=== lcfilter ===
http://www-users.cs.york.ac.uk/~fisher/lcfilter/
Online-Filterberechnung L-C-Filter

=== eispice ===

http://www.thedigitalmachine.net/eispice.html

SPICE ähnlicher Schaltungssimulator mit Python Interface

=== Yenka Analogue Electronics ===

[http://www.yenka.com/ Yenka] is a simulator for designing circuits using analogue electronic components. Mac OS X or Windows XP/Vista. You can use all Yenka products free of charge at home.

=== Solve Elec ===

With [http://www.physicsbox.com/indexsolveelec2en.html Solve Elec] you can:
* draw and analyze electrical circuits functioning in direct or alternating current
* get literal formulas and values for current intensities and voltages defined in the circuit.
* verify circuit related equations.
* draw graphs.
* get the equivalent circuit of displayed circuit
* browse an integrated documentation
* edit, save and print reports made of various elements displayed in main window
(MacOSX, Windows, Free)

===PLECS===

http://www.plexim.com/de/plecs

* Die Simulationsplattform für leistungselektronische Systeme
* als MATLAB Toolbox und Standalone erhältlich
* freie Version je nach Universität erhältlich
* 30 Tage Testversion erhältnlich
* Schaltung mit elektrischer, magnetischer, mechanischer und thermischer Domain

==Digital==

===Simulo===
http://www.codeplex.com/simulo
* Simple and modern digital simulation program. It's based upon .NET Framework 3.5 SP1 and WPF.

===DigitalSimulator===
http://www.draw2d.org/digitalsimulator/
* Windows und Online Browser Variante verfügbar

=== HADES ===
http://tams-www.informatik.uni-hamburg.de/applets/hades/html/index.html
* betriebssystemunabhängig (Java)

=== mkfilter ===
http://www-users.cs.york.ac.uk/~fisher/mkfilter/
Online-Digitalfilterberechnung FIR, IIR

=== edef ===
[http://edef.sourceforge.net/ edef] - A simple discrete event simulation. The edef framework can be used to simulate typical logical circuits, autoregressive processes or digital controller circuits and maybe some more. It is designed to be simple enougth for use in schools or other educational context. It is also truly easy to extend.

=== TkGate ===
[http://www.tkgate.org/ TkGate] is a event driven digital circuit simulator with a tcl/tk-based graphical editor. (GPL)

=== Atanua ===

[http://atanua.org/ Atanua ] is a real-time logic simulator, designed to help in learning of basic boolean logic and electronics. It uses OpenGL hardware-accelerated rendering and a custom UI designed for a fast workflow and a very low learning curve, letting the students concentrate on learning the subject instead of spending time learning the tool. (Personal non-commercial license: Free. Andere Nutzungen: siehe Webseite)

=== MMLogic ===

[http://www.softronix.com/logic.html MMLogic] is a MultiMedia Logic Design System for Windows (NT/2K/Xp/95/98/ME, now Freeware)

=== WireItUp ===

[http://www.wireitup.de WireItUp] is a Digital Logic Simulator especially made for educational purposes.(Windows 8/7/Vista/XP, Freeware)

=== Yenka Digital Electronics ===

[http://www.yenka.com/ Yenka] is a simulator for designing circuits using digital 4000 and 7400 series electronic components. Mac OS X or Windows XP/Vista. You can use all Yenka products free of charge at home.

=== KSimus ===

[http://ksimus.berlios.de/ KSimus] is a simulator for KDE.

=== Digital Simulator ===

[http://www.mit.edu/~ara/ds.html Digital Simulator] has a toolbar of digital circuit elements, including logic gates, flip-flops, switches, and indicators. Drawing a circuit with Digital Simulator is like using a paint program. You click the element's icon on the toolbar, then click where you want the element to go. You use a similar procedure to draw wires and indicate connections. It's that simple. Free for educational institutions or students. (Windows 3.1, 95/NT)

=== KLogic ===

[http://www.a-rostin.de/indexd.html KLogic] ist eine Anwendung zum einfachen Entwurf und zur Simulation von Digitalschaltungen. KLogic ermöglicht einen einfachen Aufbau von Schaltungen aus Standardkomponenten wie UND, ODER, XOR, und Flipflops wie RS und JK. Um komplexere und wiederverwendbare Schaltungen zu entwerfen, können Teilschaltungen gespeichert und wiederverwendet werden. (Linux, GPL)
Die letzte Version stammt aus dem Jahr 2006 und läuft leider recht instabil. Es gibt mittlerweile jede Menge grafisch unschöne Stellen und, schlimmer noch, auch diverse Bugs, die einen Crash verursachen.

=== Logic Simulator ===

With [http://www.tetzl.de/java_logic_simulator.html LogicSim] you can design and simulate digital logic circuits with logic gates like AND, OR, FlipFlop, etc.

=== HS-FIR-Compiler ===
[http://www.steepestascent.com/content/default.asp?page=s2_22 steepestascent.com]
14 day evaluation license:
The High Speed FIR Filter Compiler is a standalone utility that automatically generates VHDL code for fast and efficient FIR filters and is ideal for both FPGA and ASIC implementation.

=== Interactive 595 Shift Register Simulator ===

[http://conductiveresistance.com/interactive-595-shift-register-simulator/ Interactive 595 Shift Register Simulator]

=== Logic Circuit ===

[http://www.logiccircuit.org/ Logic Circuit] is free, open source educational software for designing and simulating digital logic circuits. Intuitive graphical user interface, allows you to create unrestricted circuit hierarchy with multi bit buses, debug circuits behavior with oscilloscope, and navigate running circuits hierarchy. (GPLv2, Windows: .NET 4.0 erforderlich)

== Mixed Analog-Digital ==

===SPECTRE===

Der [http://www.cadence.com/products/rf/spectre_circuit/pages/default.aspx Cadence Virtuoso Spectre Circuit Simulator] ist ein Mixed AD-Simulator auf der Basis von Spice. (Kommerziell)

===HSPICE===

[http://www.synopsys.com/Tools/Verification/AMSVerification/CircuitSimulation/HSPICE/Pages/default.aspx HSPICE] ist ein PSpice-ähnlicher Simulator, der sowohl ABM-Modelle, als auch eigens erstellte library-Modelle verarbeiten kann. (Kommerziell)

===XSPICE===
http://users.ece.gatech.edu/~mrichard/Xspice/

===ngSpice===

http://ngspice.sourceforge.net/
* Open Source (BSD-Lizenz)
* Kommandozeilenorientiert, mit graphischer Ausgabe
* Erweitert Berkeley spice3f5 [http://ngspice.sourceforge.net/extras.html um viele zusätzliche Möglichkeiten]
* für Linux, Windows, MacOS
* integriert XSPICE, daher auch für Mixed-Signal-Simulation geeignet
* eigene XSPICE code models können erstellt werden
* ausführliches Manual mit Einführung, Beipielen und allen aktuellen Features unter http://ngspice.sourceforge.net/docs/ngspice-manual.pdf

=== SMASH from DOLPHIN INTEGRATION ===
http://www.dolphin.fr/index.php/eda_solutions/products/smash/overview
* SMASH from Dolphin Integration is a mixed-signal, multi-language simulator for IP and IC designs. It uses [[SPICE]] syntax for analog descriptions, [[Verilog]]-HDL and [[VHDL]] for digital, Verilog-A/AMS, VHDL-AMS and ABCD (a combination of SPICE and C) for analog behavioral, and C for [[DSP]] algorithms.
* Logik, Analog und Mixed-Simulation
* Für Linux und Windows
* Engeschränkte Evaluationsversion erhältlich

===Micro-Cap===

http://www.spectrum-soft.com
* nur für Windows
* Evaluation Version (mit Einschränkungen) nach Registrierung erhältlich

===GNU-Radio===
http://gnuradio.org/redmine/wiki/gnuradio
GNU Radio is a free software development toolkit that provides the signal processing runtime and processing blocks to implement software radios using readily-available, low-cost external RF hardware and commodity processors. It is widely used in hobbyist, academic and commercial environments to support wireless communications research as well as to implement real-world radio systems.

=== Oregano ===

http://oregano.gforge.lug.fi.uba.ar/

Beschreibung von [http://elettrolinux.com/Simulations/oregano-an-electrical-tool.html elettrolinux.com]:

'''Oregano''' is a LINUX application for schematic capture and simulation of electronic circuits. Oregano has an user friendly graphic interface that allows to design and describe the circuit to simulate. It provides a wide variety of component libraries, including CMOS, TTL, lineal, operational amplifiers, and a lot more! Oregano lets you simulate the designed circuits. The actual simulation is performed by Berkeley Spice BSIM, GnuCAP or the new generation NGSpice. Oregano is licensed under the terms of the GNU GPL.

=== VirtualBreadboard ===

[http://www.virtualbreadboard.com/ VirtualBreadboard] is an easy to use simulation and modelling tool that can be used in place of a real breadboard for quickly performing experiments and testing out electronic and microcontroller ([[PIC]]) powered 'embedded' applications. (Seit Version 3.3.12 11 July 2009 Freeware, Windows)

=== BasicDSP ===
[http://www.vf.utwente.nl/~ptdeboer/ham/basicdsp/ von Pieter-Tjerk de Boer, PA3FWM, und Niels Moseley, PE1OIT]
A program for experimenting with simple audio DSP algorithms

===LTspice/SwitcherCAD===
http://www.linear.com/designtools/software/#LTspice

Hauptsächlich für die Simulation analoger Schaltungen verwendet, enthält LTspice doch einig digitale Grundfunktionen. Diese sind nur zum Teil im Handbuch als A-Schaltungselemente (''Circuit Elements'' --> ''A. Special Functions'') beschrieben.

==Hochfrequenztechnik==

=== Linksammlungen ===

* [http://www.circuitsage.com/tline.html Transmission Line Design and Analysis]
* [http://www.mwrf.com/Articles/Print.cfm?ArticleID=22572 Übersichtsartikel der Microwave & RF] [http://www.mwrf.com/Articles/Print.cfm?ArticleID=22809 und hier]

=== Ansoft ===
*Maxwell SV: Simulation von elektrischen und magnetischen Feldern (2D)
*Simplorer SV: Schaltungssimulation
*PExprt SV: Berechung von Schaltnetzteilen

Wurde 2008 von [http://www.ansys.com/ Ansys] gekauft,
http://www.ansys.com/Products/Simulation+Technology/Electromagnetics

die kostenlose Studentenversion "Ansoft Designer" gibts nur noch von G.Kraus:
www.gunthard-kraus.de
[http://www.gunthard-kraus.de/Ansoft%20Designer%20SV/DesignerSV050610.exe Download exe-File]
=== ARRL Radio Designer ===
für 169€ bei http://www.ukw-berichte.de erhältlich http://www.arrl.org
* Amateurversion der amerikanischen Design-Software Super Compact.
* Mittlerweile durch Ansoft Designer (ehem. Ansoft Serenade) überholt

=== AADE Filter Design ===
Homepage: http://www.aade.com/filter.htm

kostenlose Analog-Filterberechnung:
* Butterworth, Chebyshev, Elliptic (Cauer), Bessel, Legendre and Linear Phase
* low-pass, high-pass, band-Pass, and band-reject filters.
* Coupled Resonator band-pass filters
* Crystal Ladder band-pass filters using identical crystals

=== ActiveFilterDesign ===
Active Filter Design für Matlab, kostenloser Download: http://academics.vmi.edu/ee_js/Research/Programs/materials/AFD12.zip

Handbuch: http://academics.vmi.edu/ee_js/Research/Programs/materials/Analog%20Filter%20Designer.pdf

* FIR, IIR, analoge Filter, Synthese und Analyse

=== atlc - Arbitrary Transmission Line Calculator ===

* freie Software (Gnu General Public License)

Übertragungsleitungen (und eingeschlossen Richtkoppler) können mit der Open Source Software auf ihre Impedanz, aber nicht ihre Dämpfung berechnet werden.
Dabei ist die Form und Anordnung der Leiter und Dielektrica beliebig, aber die Anzahl der Leiter ist auf maximal Drei beschränkt. Es können keine Hohlleiter berechnet werden. Die üblichen Anordnungen auf Leiterplatten werden aber abgedeckt. Es wird eine Bitmap erstellt, die geometrischen und elektrischen Eigenschaften des Leitungsquerschnits als Farbe codiert enthält. Diese Bitmap wird dann vom Programm bearbeitet. Die Methode, die das Programm benutzt, ist die der [http://de.wikipedia.org/wiki/Finite-Differenzen-Methode finiten Differenzen]. Autor des Programmes ist Dr. David Kirkby alias G8WRB.
Das Programm ist in den meisten gängigen Linux Distributionen als Package erhältlich. Die Homepage mit Anleitungen, FAQ und Beispielen findet sich hier:
http://atlc.sourceforge.net/

=== AWR ===
http://web.awrcorp.com/

free trial versions erhältlich für:
* ANALOG OFFICE - High-Frequency Design Software for Analog and RFICs
* APLAC - Harmonic balance simulation engine
* AXIEM - 3D Planar Electromagnetic Software for Antennas and Passives
* MICROWAVE OFFICE - RF and Microwave Design Software for MMIC, RF PCB and Modules
* VISUAL SYSTEM SIMULATOR - Wireless Communication System Design Software

* TxLine [http://web.awrcorp.com/Usa/Products/Optional-Products/TX-Line/ free Transmission Line Calculator]

=== CST STUDIO SUITE™ ===
http://www.cst.com/

...deckt alles ab, 3D-EM Simulation für elektrostatische Probleme bis Hochfrequenz, Zeit- und Frequenzbereich, Fernfelder, EMV, Spice-Ersatzmodelle, PCBs, Partikelsimulation, Co-Simulation mit thermischen und mechanischen Problemen, Raytraycing.

=== Elsie ===
http://www.tonnesoftware.com/elsie.html
a Windows electrical filter design and analysis program handling all of the usual options (family, topology, bandwidth, etc.). It has a nice toolbox including real-time tuning modes and optimization. Outputs are presentation quality. Student edition is free.

=== FastHenry ===
Windowsversion http://www.fastfieldsolvers.com/

* open source
* Impedanzextraktion (R und L) aus 3D-Geometrieen
* Erfasst Skin-, Proximity-Effekte, magnetische Kopplungseffekte
* Erstellung von Spice-Modellen möglich

=== FilterFree ===
http://www.nuhertz.com/filter/

Filter Free is the free version of Filter Solutions and Filter Light. Functionality is limited 3rd order analog and IIR filters, and 10 tap FIR filters. Filters are synthesized. Frequency, time, and reflection analysis are performed on the ideal, unmodified filters only. Transfer functions are displayed in standard form only.

=== HP AppCAD ===
http://www.hp.woodshot.com/

RF design software is provided free of charge by Agilent Technologies
as a service to the RF and microwave design community

Läuft unter Windows ab 95c/NT4

=== Nova.exe ===
http://www.pcb-pool.com/ppde/service_downloads.html

NOVA is a program that can be used to analyze most linear (AC) circuits. It
can calculate voltage, phase, and delay at any circuit point (node) at any
frequencies. Most (AC) circuit analysis programs can only give useful results
for low frequencies (below 10 Mhz). NOVA can do this but it can also be used
for RF and microwave circuits. Microwave circuits require the analysis be done
in terms of S-parameters, rather then AC voltages. NOVA does AC, time domain,
and S-parameter analysis.This version of NOVA has circuit tweaking while in the graph mode. You may find it extremely useful. Vary a component and watch the response, return loss, and delay change.

Gutes altes DOS-Programm, AC- oder S-Parameter-Darstellung.
Ausdruck unter WinXP nur mit Screenshot-Programm möglich, getestet z. B. mit Snarf15: http://www.idcomm.com/personal/lorenblaney/SNARF15.ZIP

=== PUFF - Microwave Design Software ===
für 22€ bei http://www.ukw-berichte.de/ erhältlich
* altes DOS-Programm für HF-Simulation und Platinenentwurf
* Microstrip HF-Berechnungen, Smith-Diagramm
* in den UKW-Berichten standen schon mehrere Artikel mit Beispielen
* zur Nutzung einer Kombination aus PUFF und Ansoft SV (=Studentenversion)

Seit Anfang 2010 wird PUFF unter der GPLv3 License geführt. Der Pascal Quelltext mit Linux Package und Handbuch ist frei verfügbar. [http://wwwhome.cs.utwente.nl/~ptdeboer/ham/puff/ PUFF microwave CAD software on Linux]

=== RF-Sim 99 ===
kostenlos z. B. von: http://www.janson-soft.de/amateurfunk/rfsim99/rfsim99.htm

oder neben anderen PDFs zur HF-Technik: http://home.sandiego.edu/~ekim/e194rfs01/
* Berechnung aktiver und passiver Filter einschließlich Schaltplaneingabe
* Ausgabe von Frequenz- und Phasengang, Smith-Diagramm

=== Smith Plot ===
Neben diversen Mathcad-Beispielen und Skripten aus der HF-Technik eine Smith-Chart-Software:
http://www.fritz.dellsperger.net/downloads.htm

=== Sonnet Lite ===
Sonnet Lite provides a full-wave EM solution for 3D planar circuits
A fully functional and powerful EM analysis software.
Get started on your EM analysis within the next 30 minutes by downloading SONNET Lite!
http://www.sonnetsoftware.com/products/lite/
http://www.sonnetsoftware.com/

===qucs===
http://qucs.sourceforge.net/
* freie Software
* für Linux, Windows, OS X
* hervorragende technische Dokumentation
* Impedanzrechenfunktionen für Strip- und Microstripleitungen
* Filterberechnungstool

===ADS (Advanced Design System)===
http://www.home.agilent.com/en/pc-1297113/advanced-design-system-ads?&cc=DE&lc=ger

http://de.wikipedia.org/wiki/Advanced_Design_System

Advanced Design System, kurz ADS, ist eine spezielle Simulationssoftware der Firma Agilent zur Simulation von elektrischen Schaltungen für die Hochfrequenztechnik und stellt in diesem Segment einen Industriestandard dar.

==Antennensimulation==

=== cocoaNEC ===
Homepage: http://homepage.mac.com/chen/w7ay/cocoaNEC/index.html
* Design und modulierung von Antennen
* MacOS X (PowerPC und Intel)
* Frei erhältlich (mit Quellcode)

=== EZ-NEC ===
Homepage: http://eznec.com/
* Antennenberechnung
demo program allows only 20 segments, which limits the complexity of antenna
you can analyze. (EZNEC 4.0 allows 500 )

=== MiniNEC ===
Homepage: http://www.emsci.com/ '''(2013-05-01 Seite nicht mehr vorhanden)'''
* Antennenberechnung mittels "Momentenmethode" (Zerlegung der Antenne in kleine Segmente, Überlagerung der Teilfelder)
* eingeschränkte Studenten/Amateurversion erhältlich
* NEC = Numerical Electromagnetics Code

=== SuperNEC ===
Homepage: http://www.supernec.com/
* Antennenberechnung mittels "Momentenmethode"
* 30-Tage-Testversion sowie unbegrenzt lauffähige Studentenversion (gegen Nachweis) erhältlich

=== MMANA ===
Homepage (deutsche Version) : http://dl2kq.de/mmana/4-7.htm

Kostenlose Antennen-Analysesoftware, auf der mit MININEC Version 3 eingeführten Momentenmethode basierend

=== RadioMobile ===
Hochfrequenz-Ausbreitungssimulation
* [http://www.cplus.org/rmw/english1.html Hauptseite]
* [http://www.cplus.org/rmw/rme.html Beispielbilder]
* [http://www.cplus.org/rmw/dataen.html dazu erforderliche Kartendaten]
* [http://de.wikipedia.org/wiki/SRTM-Daten Wikipedia zum SRTM-Kartendatenformat]

== Sonstige ==

=== FEMM ===
* [http://www.femm.info/wiki/HomePage Finite Element Method Magnetics] (FEMM)

=== GALEMU ===

[http://bu3sch.de/joomla/index.php/galpal-emulator Galemu] is a [[GAL]]/[[PAL]] chip emulator. (GPL)

==Numerische Berechnungswerkzeuge==

===Derive===
http://education.ti.com

===FreeMat===
http://freemat.sourceforge.net
* freier MatLab-Clone
* für Windows, Linux, Mac OS X

===GAUSS===
Wissenschaftliche Simulationssoftware zur Berechung 3-dimensionaler Ladungsverteilungen in z. B. Halbleitern. Kann aus Geometrie und Dotierungsprofilen die Halbleitergleichungen ableiten.

===GnuPlot===
http://www.gnuplot.info/
* freie Software
* für Linux, Windows und weitere
* sehr mächtiges Tool, aber eher im Bereich der Datenauswertung (Diagramme)
* [http://ttsiodras.googlepages.com/gnuplotStreaming.html Visualize real-time data streams with Gnuplot] (Perl)

===Maple===
http://www.maplesoft.com/
* Wissenschaftliche Analyse und Simulationssystem zur Lösung komplexester Aufgaben der Mathematik. Lizenzpflichtig.

===JMathLib===
http://mathlib.sourceforge.net
* freier Matlab-Clone in 100% Java
* für Windows, Linux, ...

===MatLab===
http://www.mathworks.com/

===MuPad===
http://www.mupad.de/

===Mathcad===
http://www.mathsoft.com/ http://www.ptc.com/appserver/mkt/products/home.jsp?k=3901
* rechnen mit Formeln wie auf dem Papier

===Maxima===
http://maxima.sourceforge.net/
* freie Software für Linux, OSX, Windows

===Octave===
http://www.octave.org/
* freier MatLab-Clone. Die Syntax ist überwiegend identisch
* für Linux, Windows, OSX

===GNU R===
http://www.r-project.org/
* freier S-Clone. Die Syntax ist überwiegend identisch
* für Linux, Windows, OSX

===SciLab===
http://www.scilab.org/
* freie Software
* für Linux, Windows, MacOS
* stellt eine C++ Library bereit, die in eigene DSP-Systeme eingebunden werden kann

===scipy===
scipy [http://www.scipy.org/] ist eine Erweiterung der Skriptsprache Python [http://www.python.org] mit numerischen Funktionen
* freie Software
* für Linux, Windows, OSX

===SMathStudio===
SMathStudio [http://www.smathstudio.com/] ist ein an MathCad angelehntes numerischer Berechnungs-, Visualisierungs-, und Dokumentationstool. Die Software ist Freeware/Donationware. Sie ist ins deutsche übersetzt, wird derzeit (Stand 26.06.2012) aktiv weiterentwickelt und supported im eigenem Forum

== Online Schaltungssimulatoren ==

* [http://www.mikrocontroller.net/topic/79658#664688 Diskussion im Forum]
* http://www.falstad.com/circuit/
* [http://www.intersil.com/isim/ Intersil’s iSim]
* [http://smile.hsu-hh.de/Schaltungen/Index.htm WSPICE] (fixe Schaltungen)
* [http://micropci1.imtek.uni-freiburg.de/svs/ spicy VOLTsim]
* [http://www.gecko-simulations.com/geckocircuits.html GeckoCIRCUITS]
* [https://www.circuitlab.com CircuitLab]
* [http://www.poweresim.com/ PowerEsim] - Free SMPS Switching Power Supply / Transformer Design Software

== Tutorials ==

* [http://www.elektronikschule.de/~krausg/ Elektronikschule.de von Gunthard Kraus] (ORCAD-PSPICE, LTspice IV)

[[Kategorie:Entwicklungstools]]
[[Kategorie:Schaltplaneditoren]]

200MHz DDS-Generator

2014-04-17T09:02:17Z

Kichi: /* Spezifikationen */

== Übersicht ==
In diesem Projekt soll versucht werden, einen hochwertigen, aber trotzdem kostengünstigen Sinus-Generator mit einer maximalen Ausgangsfrequenz von 180MHz bis 200MHz auf Basis einer [[DDS]] zu bauen. Die Materialkosten sollen 200€ nicht überschreiten.

== Spezifikationen ==
* 180MHz
* Option um mit Aliasfilter bis 360MHz und ggf. 620MHz zu erzeugen - hierbei aber das Phasenrauschen im Auge behalten. Ggf. ist diesbezüglich eine Lösung mit einem Mischer und PLL vernünftiger (aber auch teurer).
* Sinus Ausgang
* Optional Rechteck Ausgang via Komparator
* DC-Offset?
* Ausgangspegel bis 23dBm, einstellbar
* Modularer Aufbau, damit Funktionen ergänzt oder weggelassen werden können
* Option zum Einspeisen eines externen Referenztaktes
* Option: guter CTXO (z. B. von CMAC) zu verlöten
* Option: Steuerung via Bluetooth->Seriell-Wandler

== Pflichtenheft==
Zweck:
Hier sollen die exakten Spezifikationen für den DDS-Generator festgehalten und verwaltet werden

Kurze Beschreibung der Baugruppen:
* Der DDS Generator soll modular aufgebaut werden damit HF Dichtigkeit gewaehrleistet ist. Die Schaltung soll wie folgend in Baugruppen aufgeteilt werden:
** Netzteil/DC Power Schaltung. Stellt alle Spannungen bereit und elektonische Hybrid/uC Ein/Ausschaltungsteuerung. Spannungen je nach uC, jedenfaflls +12V, 5V. Die DDS Baugruppe soll eingebaute Regler fuer 3.3V/1.8V mit Rauschfilterung haben
** DDS Hauptmodul mit DDS IC, Filter, Verstärker, Pegel Feineinstellung, AM Modulator
** Digital gesteuerter HF Abschwächer mit entweder I2C oder Direkter Relaissteuerung.
** Optionaler DSP FM Modulator zur Nachrüstung um digitale FM Modulation(FM, FSK, PSK, FM-Stereo) zu ermöglichen.
** uC Hautptplatine. Entweder selbstgefertigt oder kommerzielle Platine
** USB Interface mit FTDI232RL
** Optionale CGI Web Server Modul fuer Steuerung der DDS Funktionen mit Web Browser oder LabVIEW oder ähnlich.

Abmessungen:

Userinterface - Anzeigen:

Definition Umweltbedingungen:
* Der Generator soll von -20°C bis 85°C lagerfähig sein. (Lagertemperatur)
* Die Elektronik soll von 0°C bis 55°C einsatzfähig sein. (Betriebstemperatur)
* Die Elektonik soll von -20°C bis 85°C versandfähig sein. (Versandtemperatur)
* Die Schaltung soll von 600 bis 1200 mbar arbeiten.
* Die Luftfeuchtigkeit, in der die Schaltung einwandfrei arbeitet soll zwischen 20% und 80% liegen. (Nicht kondensierend)

Wasserdichtigkeit /IP-Klasse:
IPX0

Netzeingang, Sicherungen, Netzfilter:
* Es soll eine Sicherung vorgesehen werden.
* Es soll ein Varistor gegen Surges / Spikes vorgesehen werden.

Normen und Standards:

Sicherheitsfunktionen:
* Spezielle Sicherheitsfunktionen sollen nicht vorgesehen werden.

Schutzfunktionen:

Sicherungen:

Abschaltungskriterien:

Servicefunktionen:
* Einige BITE Funktionen sind wuenschenswert.
* Eingebaute uC Abgleichhilfen sollten nach Moeglichkeit in Betracht gezogen werden.
Definitionen Betriebsspannungen:

Pegel:
* Der Ausgangspegel soll den Bereich von mindestens +13dBm bis -136dBm in 0.01dB Schritten überstreichen.
* Der Abschwächer soll einen Bereich bis 127dB in 1dB Schritten haben. Zwischen 1dB wird der Ausgangspegel des DDS DAC fein eingestellt.
* System Impedanz soll 50Ω sein.
Ausgänge:
* Hauptausgang im Bereich von +13dBm bis -136dBm.
* Sync Ausgang in TTL/CMOS
* Sweep X Ausgang 0-10V zur Ansteuerung eines Oszilloskop mit 10bit Aufloesung.
* TTL Markerausgang mit der DDS Abstimmung gekoppelt so dass genaue Frequenzmessungen mittels der DDS Anzeige und Oszilloskopdarstellung möglich sind. TTL Pegel.

Eingänge:
* Eingang fuer einen HF Detector mit logarithmischen Ausgang so dass man den DDS Generator fuer Netzwerkmessungen bequem verwenden kann. Die HF Werte sollen über die Schnittstellen ansprechbar sein so dass ein PC zur weiteren Anzeige und Steuerung dienen kann. Der HF Detector kann analog oder digitale Ausgaenge haben(I2C, SPI, UART, USB) mit mindestens 16-bit Aufloesung.
* Externer Referenzfrequenzeingang zwischen 1-40MHz. Nachführung der DDS Zeitbasis entweder mit schmalbandiger PLL (solange der Oszillator elektronisch abgestimmt werden kann) oder digitale Kompensation mittels Frequenzzähler und uC Korrektur in der DDS Datenaufbereitung.

Aufbau Leiterplatten:
* Die Leiterplatten sollen aus 1,6mm starken FR4 gefertigt werden.
* Die Leiterplatten sollen 2-Lagig ausgeführt werden.
* Die Leiterplatten werden mit Stopplack unten und oben versehen.
* Es wird kein Bestückdruck vorgesehen.

Design Details:
* Isolationen sollen, wenn möglich mit 5/3mm Luft und Krichstrecke ausgeführt werden.

* Teiler für analoge Signale sollen als Widerstände eingeplant werden.
* Alle wichtigen Ein- und Ausgänge sollen mit einem PAD zur Prüfen versehen werden.
* Die minimale Leiterbahnbreite soll 0,2mm betragen.
* Der minimaler Restring soll 0,2mm betragen.
* Der minimaler Abstand soll 0,2mm betragen.
* Beschriftungen sollen ins Kupfer geschrieben werden.
* Die Leiterplatten soll mit "TOP" und "BOTT" gekennzeichnet werden.
* Die Leiterplatten soll mit zwei Fiducicals versehen werden. ( 1.5mm Kreis Kupfer, Stopplack 2mm im Quadrat ausgespart.)
* Die Leiterplatten sollen mit XXX gekennzeichnet werden.

Ausführliche Schaltungsbeschreibung:
* Stromversorgungsbaugruppe:
* Die Stromversorgungsbaugruppe soll zwei Eingänge besitzen.
* Beide Eingänge sollen von 8-30V Eingangsspannung ausgelegt sein.
* An einen Eingang soll ein internes Netzteil angeschlossen werden.
* An den zweiten Eingang soll ein externes Netzteil angeschlossen werden.
* Optional soll eine Lademöglichkeit für die nachträgliche Aufrüstung mit Lithium-Ionen-Akkus vorgesehen werden.
* Die beiden Spannungen sollen miteinander "Ver-Odert" werden. Dazu soll eine Ideale Diode mit MOSFET und Steuerchip von Linear Technology eingesetzt werden.
* Die 12V sollen mit einem Spannungsregler Typ LTC3780 von Linear Technologie erzeugt werden.
* Die 5 Volt sollen mit einem Spannungregler Typ LM25575 von National erzeugt werden.
* GGv. sollen die Spannungen auf 12,5V und 5,5V eingestellt werden, um auf den folgenden Baugruppen eine rausch und ripple-freie Spannung mit einem LDO erzeugen zu können.

Anzeigeeinheit:
* LCD 4x20 HD44780 kompatibel oder ein Grafik-LCD-Display-Modul.
* Menüführung über Tasten oder opt. Encoder.

== Blockschaltbild ==
* Hier ist ein vorläufiges Blockschaltbild von meinem geplanten Konzept mit dem AD9951 als DDS Kern.
*[[Datei:DDS_Blockdiagram_R2.pdf]]

== Komponenten ==
=== Steuerteil ===
Die Steuerung soll ein µC (ATMega) übernehmen. Über eine Tastatur, einen Inkrementalgeber und ein alphanumerisches 2*16 Zeichen Display können die Parameter eingestellt werden.
Zusätzlich ist die Steuerung und Programmierung über eine isolierte USB Schnittstelle (FT232 Bus Supply o.ä. mit Optokoppler an TX und RX Signal) möglich.

=== DDS ===
Als DDS Chip könnte der AD9951 dienen ([http://www.analog.com/static/imported-files/Data_Sheets/AD9951.pdf Datenblatt]). Allerdings hat der AD9954 bei fast gleichem Preis einen integrierten Komparator und ein 1024x32 RAM welches das Frequenz sweeping erleichtert:
[http://www.analog.com/static/imported-files/Data_Sheets/AD9954.pdf Datenblatt]
Da der Chip einen symetrischen Ausgang hat kann sein Signal über einen Breitbandübertrager geführt werden um Störungen zu reduzieren. Die Möglichkeit, den Chip leicht zu übertakten, muss noch geprüft werden.

Als Alternative bietet sich der 9910 an, der standardmässig bis 400MHz arbeiten kann und eine Reihe weiterer Modulationsfunktionen bietet.

=== Filter ===

=== Verstärker ===

=== Abschwächer ===
Zur Zeit ist ein binärer Abschwächer mit 127dB Bereich und den G6K-2P Relais im Aufbau zur Erprobung. I2C Schnittstelle mit TPIC2810 und optionales EEPROM für Korrekturtabelle. Frequenzbereich DC-300MHz. Mehr Informationen kommen in den nächsten paar Wochen.

=== Gehäuse ===
Als Gehäuse ist eventuell ein Aparaturgehäuse wie das CP-15-33 sinvoll: [http://zefiryn.tme.pl/dok/a30/cp-15-33.pdf Datenblatt]. Eine andere hochwertigere und teurere Möglichkeit ist ein Metallgehäuse.

== Ressourcen ==
=== Ähnliche Projekte ===
* [http://www.dl1alt.de/ www.dl1alt.de -> NWT-201]
* [http://www-public.tu-bs.de:8080/~y0023797/DA/Diplomarbeit.pdf Diplomarbeit: DDS-Generator bis 120 MHz] (down)
* [http://albinotroll.nerx.net/artikel/diplomarbeit_frequenzgenerator.pdf Diplomarbeit: Frequenzgenerator 100 MHz] (down)
* Funkamateur 3/08 High End DDS VFO mit dem AD9912
* Funkamateur 3/07 Vektorieller Antennenanalysator mit AD9958
* Funkamateur 11/06 Netzwerktester mit AD9951
* Funkamateur 11/05 DDS VFO fuer 2-m Transceiver
* [http://www.mikrocontroller.net/articles/DDS_basierter_Funktionsgenerator_mit_AD5930 Funktionsgenerator mit AD5930]

=== Nützliche Infos ===
* [http://www.coilcraft.com/ www.coilcraft.com -> Breitbandübertrager]
* [http://www.minicircuits.com/ www.minicircuits.com -> Verstärker, Abschwächer]
* [http://www.aade.com/filter32/download.htm www.aade.com/filter32/download.htm -> AADE Filter Designer und Simulator]
* [http://www.analog.com/static/imported-files/tutorials/450968421DDS_Tutorial_rev12-2-99.pdf A Technical Tutorial on Digital Signal Synthesis]

'''Vorschläge sind jederzeit willkommen!'''

Diskussion zu diesem Projekt: http://www.mikrocontroller.net/topic/166831

[[Kategorie:Signalgeneratoren]]

200MHz DDS-Generator

2014-04-17T09:01:44Z

Kichi: /* Spezifikationen */

== Übersicht ==
In diesem Projekt soll versucht werden, einen hochwertigen, aber trotzdem kostengünstigen Sinus-Generator mit einer maximalen Ausgangsfrequenz von 180MHz bis 200MHz auf Basis einer [[DDS]] zu bauen. Die Materialkosten sollen 200€ nicht überschreiten.

== Spezifikationen ==
* 180MHz
* Option um mit Aliasfilter bis 360MHz und ggf. 620MHz zu erzeugen - hierbei aber das Phasenrauschen im Auge behalten. Ggf. ist diesbezüglich eine Lösung mit einem Mischer und PLL vernünftiger (aber auch teurer).
* Sinus Ausgang
* Optional Rechteck Ausgang via Komperator
* DC-Offset?
* Ausgangspegel bis 23dBm, einstellbar
* Modularer Aufbau, damit Funktionen ergänzt oder weggelassen werden können
* Option zum Einspeisen eines externen Referenztaktes
* Option: guter CTXO (z. B. von CMAC) zu verlöten
* Option: Steuerung via Bluetooth->Seriel Wandler

== Pflichtenheft==
Zweck:
Hier sollen die exakten Spezifikationen für den DDS-Generator festgehalten und verwaltet werden

Kurze Beschreibung der Baugruppen:
* Der DDS Generator soll modular aufgebaut werden damit HF Dichtigkeit gewaehrleistet ist. Die Schaltung soll wie folgend in Baugruppen aufgeteilt werden:
** Netzteil/DC Power Schaltung. Stellt alle Spannungen bereit und elektonische Hybrid/uC Ein/Ausschaltungsteuerung. Spannungen je nach uC, jedenfaflls +12V, 5V. Die DDS Baugruppe soll eingebaute Regler fuer 3.3V/1.8V mit Rauschfilterung haben
** DDS Hauptmodul mit DDS IC, Filter, Verstärker, Pegel Feineinstellung, AM Modulator
** Digital gesteuerter HF Abschwächer mit entweder I2C oder Direkter Relaissteuerung.
** Optionaler DSP FM Modulator zur Nachrüstung um digitale FM Modulation(FM, FSK, PSK, FM-Stereo) zu ermöglichen.
** uC Hautptplatine. Entweder selbstgefertigt oder kommerzielle Platine
** USB Interface mit FTDI232RL
** Optionale CGI Web Server Modul fuer Steuerung der DDS Funktionen mit Web Browser oder LabVIEW oder ähnlich.

Abmessungen:

Userinterface - Anzeigen:

Definition Umweltbedingungen:
* Der Generator soll von -20°C bis 85°C lagerfähig sein. (Lagertemperatur)
* Die Elektronik soll von 0°C bis 55°C einsatzfähig sein. (Betriebstemperatur)
* Die Elektonik soll von -20°C bis 85°C versandfähig sein. (Versandtemperatur)
* Die Schaltung soll von 600 bis 1200 mbar arbeiten.
* Die Luftfeuchtigkeit, in der die Schaltung einwandfrei arbeitet soll zwischen 20% und 80% liegen. (Nicht kondensierend)

Wasserdichtigkeit /IP-Klasse:
IPX0

Netzeingang, Sicherungen, Netzfilter:
* Es soll eine Sicherung vorgesehen werden.
* Es soll ein Varistor gegen Surges / Spikes vorgesehen werden.

Normen und Standards:

Sicherheitsfunktionen:
* Spezielle Sicherheitsfunktionen sollen nicht vorgesehen werden.

Schutzfunktionen:

Sicherungen:

Abschaltungskriterien:

Servicefunktionen:
* Einige BITE Funktionen sind wuenschenswert.
* Eingebaute uC Abgleichhilfen sollten nach Moeglichkeit in Betracht gezogen werden.
Definitionen Betriebsspannungen:

Pegel:
* Der Ausgangspegel soll den Bereich von mindestens +13dBm bis -136dBm in 0.01dB Schritten überstreichen.
* Der Abschwächer soll einen Bereich bis 127dB in 1dB Schritten haben. Zwischen 1dB wird der Ausgangspegel des DDS DAC fein eingestellt.
* System Impedanz soll 50Ω sein.
Ausgänge:
* Hauptausgang im Bereich von +13dBm bis -136dBm.
* Sync Ausgang in TTL/CMOS
* Sweep X Ausgang 0-10V zur Ansteuerung eines Oszilloskop mit 10bit Aufloesung.
* TTL Markerausgang mit der DDS Abstimmung gekoppelt so dass genaue Frequenzmessungen mittels der DDS Anzeige und Oszilloskopdarstellung möglich sind. TTL Pegel.

Eingänge:
* Eingang fuer einen HF Detector mit logarithmischen Ausgang so dass man den DDS Generator fuer Netzwerkmessungen bequem verwenden kann. Die HF Werte sollen über die Schnittstellen ansprechbar sein so dass ein PC zur weiteren Anzeige und Steuerung dienen kann. Der HF Detector kann analog oder digitale Ausgaenge haben(I2C, SPI, UART, USB) mit mindestens 16-bit Aufloesung.
* Externer Referenzfrequenzeingang zwischen 1-40MHz. Nachführung der DDS Zeitbasis entweder mit schmalbandiger PLL (solange der Oszillator elektronisch abgestimmt werden kann) oder digitale Kompensation mittels Frequenzzähler und uC Korrektur in der DDS Datenaufbereitung.

Aufbau Leiterplatten:
* Die Leiterplatten sollen aus 1,6mm starken FR4 gefertigt werden.
* Die Leiterplatten sollen 2-Lagig ausgeführt werden.
* Die Leiterplatten werden mit Stopplack unten und oben versehen.
* Es wird kein Bestückdruck vorgesehen.

Design Details:
* Isolationen sollen, wenn möglich mit 5/3mm Luft und Krichstrecke ausgeführt werden.

* Teiler für analoge Signale sollen als Widerstände eingeplant werden.
* Alle wichtigen Ein- und Ausgänge sollen mit einem PAD zur Prüfen versehen werden.
* Die minimale Leiterbahnbreite soll 0,2mm betragen.
* Der minimaler Restring soll 0,2mm betragen.
* Der minimaler Abstand soll 0,2mm betragen.
* Beschriftungen sollen ins Kupfer geschrieben werden.
* Die Leiterplatten soll mit "TOP" und "BOTT" gekennzeichnet werden.
* Die Leiterplatten soll mit zwei Fiducicals versehen werden. ( 1.5mm Kreis Kupfer, Stopplack 2mm im Quadrat ausgespart.)
* Die Leiterplatten sollen mit XXX gekennzeichnet werden.

Ausführliche Schaltungsbeschreibung:
* Stromversorgungsbaugruppe:
* Die Stromversorgungsbaugruppe soll zwei Eingänge besitzen.
* Beide Eingänge sollen von 8-30V Eingangsspannung ausgelegt sein.
* An einen Eingang soll ein internes Netzteil angeschlossen werden.
* An den zweiten Eingang soll ein externes Netzteil angeschlossen werden.
* Optional soll eine Lademöglichkeit für die nachträgliche Aufrüstung mit Lithium-Ionen-Akkus vorgesehen werden.
* Die beiden Spannungen sollen miteinander "Ver-Odert" werden. Dazu soll eine Ideale Diode mit MOSFET und Steuerchip von Linear Technology eingesetzt werden.
* Die 12V sollen mit einem Spannungsregler Typ LTC3780 von Linear Technologie erzeugt werden.
* Die 5 Volt sollen mit einem Spannungregler Typ LM25575 von National erzeugt werden.
* GGv. sollen die Spannungen auf 12,5V und 5,5V eingestellt werden, um auf den folgenden Baugruppen eine rausch und ripple-freie Spannung mit einem LDO erzeugen zu können.

Anzeigeeinheit:
* LCD 4x20 HD44780 kompatibel oder ein Grafik-LCD-Display-Modul.
* Menüführung über Tasten oder opt. Encoder.

== Blockschaltbild ==
* Hier ist ein vorläufiges Blockschaltbild von meinem geplanten Konzept mit dem AD9951 als DDS Kern.
*[[Datei:DDS_Blockdiagram_R2.pdf]]

== Komponenten ==
=== Steuerteil ===
Die Steuerung soll ein µC (ATMega) übernehmen. Über eine Tastatur, einen Inkrementalgeber und ein alphanumerisches 2*16 Zeichen Display können die Parameter eingestellt werden.
Zusätzlich ist die Steuerung und Programmierung über eine isolierte USB Schnittstelle (FT232 Bus Supply o.ä. mit Optokoppler an TX und RX Signal) möglich.

=== DDS ===
Als DDS Chip könnte der AD9951 dienen ([http://www.analog.com/static/imported-files/Data_Sheets/AD9951.pdf Datenblatt]). Allerdings hat der AD9954 bei fast gleichem Preis einen integrierten Komparator und ein 1024x32 RAM welches das Frequenz sweeping erleichtert:
[http://www.analog.com/static/imported-files/Data_Sheets/AD9954.pdf Datenblatt]
Da der Chip einen symetrischen Ausgang hat kann sein Signal über einen Breitbandübertrager geführt werden um Störungen zu reduzieren. Die Möglichkeit, den Chip leicht zu übertakten, muss noch geprüft werden.

Als Alternative bietet sich der 9910 an, der standardmässig bis 400MHz arbeiten kann und eine Reihe weiterer Modulationsfunktionen bietet.

=== Filter ===

=== Verstärker ===

=== Abschwächer ===
Zur Zeit ist ein binärer Abschwächer mit 127dB Bereich und den G6K-2P Relais im Aufbau zur Erprobung. I2C Schnittstelle mit TPIC2810 und optionales EEPROM für Korrekturtabelle. Frequenzbereich DC-300MHz. Mehr Informationen kommen in den nächsten paar Wochen.

=== Gehäuse ===
Als Gehäuse ist eventuell ein Aparaturgehäuse wie das CP-15-33 sinvoll: [http://zefiryn.tme.pl/dok/a30/cp-15-33.pdf Datenblatt]. Eine andere hochwertigere und teurere Möglichkeit ist ein Metallgehäuse.

== Ressourcen ==
=== Ähnliche Projekte ===
* [http://www.dl1alt.de/ www.dl1alt.de -> NWT-201]
* [http://www-public.tu-bs.de:8080/~y0023797/DA/Diplomarbeit.pdf Diplomarbeit: DDS-Generator bis 120 MHz] (down)
* [http://albinotroll.nerx.net/artikel/diplomarbeit_frequenzgenerator.pdf Diplomarbeit: Frequenzgenerator 100 MHz] (down)
* Funkamateur 3/08 High End DDS VFO mit dem AD9912
* Funkamateur 3/07 Vektorieller Antennenanalysator mit AD9958
* Funkamateur 11/06 Netzwerktester mit AD9951
* Funkamateur 11/05 DDS VFO fuer 2-m Transceiver
* [http://www.mikrocontroller.net/articles/DDS_basierter_Funktionsgenerator_mit_AD5930 Funktionsgenerator mit AD5930]

=== Nützliche Infos ===
* [http://www.coilcraft.com/ www.coilcraft.com -> Breitbandübertrager]
* [http://www.minicircuits.com/ www.minicircuits.com -> Verstärker, Abschwächer]
* [http://www.aade.com/filter32/download.htm www.aade.com/filter32/download.htm -> AADE Filter Designer und Simulator]
* [http://www.analog.com/static/imported-files/tutorials/450968421DDS_Tutorial_rev12-2-99.pdf A Technical Tutorial on Digital Signal Synthesis]

'''Vorschläge sind jederzeit willkommen!'''

Diskussion zu diesem Projekt: http://www.mikrocontroller.net/topic/166831

[[Kategorie:Signalgeneratoren]]

STM32 Eclipse Installation

2014-01-24T08:09:17Z

Kichi: /* MicroXplorer - MCU graphical configuration tool */

Dieser Artikel beschreibt, wie man Eclipse unter Windows installiert und für den Prozessor STM32 einrichtet, so dass ein Debuggen möglich ist.

== Installation von Eclipse unter Windows ==

'''Die Zusammenhänge:'''
* Eclipse - der Editor, ist eigentlich nichts weiteres als ein Editor, mit sehr viel Intelligenz
* Toolchain (make, Compiler, Linker, GDB, Bibliotheken, etc.). Hier gibt es verschiedene Möglichkeiten:
** YAGARTO GNU ARM toolchain - der Compiler und Debugger für Cortex-M3. Zusätzlich werden die Yagarto-Tools (make und sonstige Programme) benötigt.
** CodeSourcery - beinhaltet alle benötigten Tools, wie make, GCC, GDB, Newlib usw.
** GNU Tools for ARM Embedded Processors - benötigt zusätzlich ebenfalls make und rm bspw. aus den Yagarto-Tools
* CDT - Plugin, das Eclipse erweitert, sodaß C/C++ Programme editiert, kompiliert und gelinkt werden können. CDT steht für "C/C++ Development Tooling". Man kann Eclipse auch mit schon integrierten CDT auf der Eclipse Homepage bekommen.
* GDB Hardware Debugging - ein weiteres Eclipse-Plugin, welches notwendig ist, um mittels GDB und weiteren Tools Programme zu debuggen.
* GDB - der GNU Debugger, mit ihm ist es möglich, entsprechend kompilierte Programme auf C-Sourcelevel (und auch Assembler) zu debuggen. Er kann allerdings nicht direkt mit einem JTAG-Interface sprechen. Er "verbindet" sich dafür mit einem GDB-Server, der dann das JTAG-I/F anspricht.
* GDB-Server - stellt eine Verbindung mit GDB und dem JTAG-Interface her. Er führt die Kommandos des GDBs aus. Der Server muss vor dem debuggen gestartet werden, da GDB einen laufenden GDB-Server erwartet. Die Verbindung zwischen dem GDB und dem GDB-Server wird über eine TCP/IP Verbindung hergestellt.
** OpenOCD - ein freier GDB-Server
** Texane STlink - ebenfalls frei
* JTAG-Interface, z.B. Olimex ARM-USB-OCD, ST-Link oder diverse andere. Meist über USB an den PC angeschlossen, über ein JTAG-Kabel wird der Adapter mit der Prozessor-Platine verbunden. Der GDB-Server nimmt Kommandos vom GDB entgegen und führt diese über das JTAG-I/F des Prozessors aus.
* STM32-Prozessor, ja den braucht es auch noch, sonst gibt es nichts zu debuggen.

Es sieht zwar auf den ersten Blick etwas komplex aus, aber es ist dennoch logisch aufgebaut.

== Downloads ==

Die benötigten Dateien für Eclipse:

* [http://yagarto.de/ Yagarto-Tools http://yagarto.de/]
* [http://www.oracle.com/technetwork/java/javase/downloads/index.html Java JDK] Installation um Eclipse starten zu können.
* [http://eclipse.org/downloads/ Eclipse], der Download "Eclipse IDE for C/C++ Developers"
* [http://www.freddiechopin.info/ OpenOCD http://www.freddiechopin.info/] >> Download >> Software >> OpenOCD

''' Eclipse Demo-Projekt: '''

[[Media: Proj_Demo.zip | Blink-LED, komplettes Eclipse-Workspace von MmVisual]]
* Eclipse Workspace
* Mit OpenOCD und Dateien für den Olimex ARM-USB-OCD
* FW-Lib 3.4.0 von ST
* Start-Up Code als C-Datei, keine einzige Assembler-Datei
* Für STM32F103RB (128K Flash) wegen Initialisierung Stack-Pointer
* Nutzt make Tool, muss aber zu gmake umbenannt werden, ist weiter unten beschrieben

== Installation ==
=== Installation von Eclipse ===
Damit Eclipse gestartet werden kann, ist es nötig, dass zunächst Java installiert wird. Dabei muss einfach den Anweisungen des Installers gefolgt werden. Nachdem diese Installation abgeschlossen wurde, kann mit der Eclipse "Installation" fortgefahren werden.

Eclipse befindet sich (sofern im Download ausgewählt) in einem ZIP-Archiv. In diesem Archiv sind alle benötigten Dateien vorhanden, um Eclipse direkt starten zu können. Dieses ZIP-Archiv sollte dann zu C:\eclipse\ entpackt werden. In diesem Beispiel wird davon ausgegangen, dass eclipse zu den o.g. Pfad entpackt wird.

Sobald Eclipse vollständig entpackt wurde, kann eclipse gestartet werden. Während Eclipse startet, muss ein sog. Workspace ausgewählt werden. In diesem Workspace werden später alle Projekte und Sourcecodes abgelegt. Die Nachfolgende Grafik zeigt dieses Dialog-Fenster.
[[Datei:choose_workspace.png]]
Nachdem Eclipse erfolgreich gestartet werden kann, ist die Installation natürlich nicht abgeschlossen, da noch ein Compiler usw. für dem ARM-Mikrocontroller fehlt.

Für die Toolchain, sprich Compiler, newlib usw. hat man nun die Qual der Wahl, entweder man nimmt Yagarto-Tools oder Codesourcery. Der Unterschied zwischen den beiden toolchains ist nicht direkt erkennbar und soll an dieser Stelle nicht weiter behandelt werden. Ich verweise an dieser Stelle an den folgenden Foreneintrag:
[[http://www.mikrocontroller.net/topic/158503#1503836 Unterschied WinARM und Codesourcery]]

Ich persönlich habe mich für Codesourcery entschieden, da Truestuido von Atollic ebenfalls den none-eabi Compiler verwendet und dadurch die Linkerscripts direkt von Truestudio übernommen werden können.

=== Installation der Code-Sourcery Umgebung ===
Wer sich nun für die Code-Sourcery Umgebung entschieden hat, steht nun schon vor einem kleinerem Problem - Welche Version von Code-Sourcery soll man wählen?
Zur Auswahl stehen folgende Versionen:
* uCLinux
* EABI
* GNU/Linux
* SymbianOS
Hier ist die Wahl auf EABI beschränkt. Für weitere Hinweise siehe: [[http://www.codesourcery.com/sgpp/lite/arm/portal/doc9876/getting-started.pdf Codesourcery Getting-Started]]

Die Installation von Code-Sourcery ist komplett Menü geführt und entsprechend intuitiv durchzuführen. Dabei werden nachfolgend die wichtigsten Komponenten kurz erläutert:

CodeSourcery Common Startup Code Sequence
Diese vordefinierten Startup-Codes werden für den Start des Mikrocontrollers benutzt. Dabei wird der Stackpointer, die Interrupt-Handler usw. initialisiert. Die Benutzung dieser Startupcodes wird hier nicht näher Betrachtet, da STM vorgefertigte Startup-Codes kostenlos anbietet.

* CodeSourcery Debug Sprite for ARM
Die Debug-Sprite Umgebung ermöglicht das Debuggen eines Mikrocontrollers über JTAG. Debug-Sprite kann dabei über XML-Dateien konfiguriert werden. Jedoch kann Debug-Sprite nicht für das Debuggen von STM32-Mikrocontrollern verwendet werden.
GNU Binary Utilities (Binutils)
Die Binutils beinhaltet den GNU-Assembler sowie den für das Übersetzen eines C-Software-Modules benötigen Linker.

* GNU C Compiler (GCC)
Der GNU-C Compiler übersetzt den C-Code zu den sog. Object-Codes.

* GNU C++ Compiler (G++)
Der G++ Compiler übersetzt ein C++-Software-Modul zu Object-Codes, um damit die Verwendung von C++ auf einem Mikrocontroller zu ermöglichen.

* GNU C++ Runtime Library (Libstdc++)
Diese Library stellt C++ spezifische Funktionen zu Verfügung.

* GNU Debugger (GDB)
Der Debugger ist der GDB-Client, der für das Debuggen eines Software-Moduls genutzt wird.

* Newlib C Library

Die Newlib stellt die std-Lib für einen Mikrocontroller zu Verfügung. Dabei ist zu beachten, das die Newlib syscalls und stubs nutzt, um so eine Betriebssystemunabhängige Benutzung zu ermöglichen. Dies ermöglicht die Benutzung der Newlib auf einem Bare-Metal-System und auf einem uC-Linux basiertem Software-Modul.

Ich persönlich habe als Installationsverzeichnis C:\WinARM benutzt, damit die entsprechenden Pfade zu bestimmten binaris keine großartigen Sonderzeichen aufweisen.

=== Installation der Yagarto Umgebung ===
Die Installation sollte so ausgeführt werden, dass alles nach "C:\WinARM\" installiert wird, dazu müssen in den Setup-Paketen während des Setups immer die Pfade "C:\Programme\" angepasst werden. Damit kann man die gesamte Entwicklung und Konfiguration einfach sichern als ZIP Datei und sogar bei einem zweiten Rechner wieder einspielen.

Zu erst werden die Downloads von Yagarto geladen und installiert. Dort ist auch sehr gut beschrieben wie das Einrichten geht.
Allerdings fehlt auf der Yagarto-Seite der Hinweis auf den Download-Link des eigentlichen Eclipse Programms, daher ist er oben im Artikel aufgeführt.

Wenn man diese [http://yagarto.de/howto/yagarto2/index.html#download Yagarto-Anleitung] abgeschlossen hat kommt die Einrichtung von OpenOCD.
Eine Debugger-Einrichtung ist bei [http://yagarto.de/howto/yagarto2/index.html#cbug Yagarto] auch beschrieben, allerdings nicht für den STM32 Prozessor.

Nach der Installation von Yagarto-Tools muss eine Datei geändert werden:
C:\WinARM\yagarto-tools\bin\make.exe muss nach gmake.exe umbenannt werden.
Grund: Wenn man Delphi installiert hat, dann würde Eclipse das make Tool von Delphi finden und man kann das Eclipse Projekt nicht kompilieren.
Das Demo-Projekt nutzt auch das "gmake.exe".
Alternativ kann auch make.exe kopiert zu gmake.exe werden, wenn man kein Delphi installiert hat.

==== Start mit dem Demo-Projekt ====

Für alle Projekte habe ich das Verzeichnis C:\WinARM\Projekt\ vorgesehen, damit ist immer alles zusammen. Nun entpackt man das Demo-Projekt nach C:\WinARM\Projekt\ somit müsste dort ein neues Unterverzeichnis "Proj_Demo" vorhanden sein samt allen unterordnern.

Nun Eclipse Öffnen. Menü "File" >> "Switch Workspace" >> "Other...". In der Eingabezeile "Workspace:" wird nun das Verzeichnis "C:\WinARM\Projekt\Proj_Demo" eingegeben. Mit OK wird sich Eclipse beenden und neu starten.

Links im Baum sieht man das Projekt "BlinkLED":
* inc: die eigenen Includes
* lib: die FW-Lib von ST
* out: die kompilierten Dateien und listings
* prj: OpenOCD und LD Linker-Datei
* src: die eigenen Quellcodes
* makefile

Das Projekt wurde geschrieben für den STM32F103RC (256K Flash/48K RAM), läuft aber auch mit einem STM32F103xB da der Stack-Pointer auf 20K initialisiert wird. Details stehen in der Datei "src/stm32f10x_vector.c", Zeile 29,30:
<syntaxhighlight lang="c">#define STACK_TOP (0x20005000 - 4)
//#define STACK_TOP (0x2000C000 - 4)</syntaxhighlight>
Damit wird der Stack-Pointer für den RAM im Chip initialisiert.

Zum kompilieren rechten Mausklick auf das Projekt (normalerweise links im Navigator oder Projekt-Explorer) und dann im aufgehenden Kontextmenu auf "Build" klicken.
Mit Strg+B wird nicht nur das Projekt neu kompiliert sondern ALLE Projekte im aktuellen Workspace gerade offen sind. Wenn man dort nur ein Projekt hat geht auch CTRL-B.

''' Die Funktionen des Demo-Projekts '''
* Blink-LED auf Prot A.0, Port C.7, PortD.3,4,7,13 (STM3210C-EVAL Board)
* Initialisieren aller Variablen
* Initialisieren Clock auf HSI, 8MHz
* Initialisieren IO-Pins der LED's
* Initialisieren Timer für Systick
* Main-Schleife in der die Timer-Variablen gesetzt und die LED's ausgegeben werden
* Debug-Helper, siehe "src\DebugHelper.c"
* Systick-Interrupt
* komplett in C programmiert, kein Assembler
* ST FW-Lib V3.4.0 wird für alle Funktionen genutzt

'''Erster Start mit dem Demo-Projekt'''

Mit Eclipse mit der grünen Play-Taste mit dem roten Koffer "Run OpenOCD BlinkLED" "OpenOCD BlinkLED starten. Damit wird der GDB Server OpenOCD mit dem JTAG-Key ARM-USB-OCD gestartet. Wenn man einen anderen JTAG Adapter hat, so kann der mit dem kleinen schwarzen Pfeil im Menü "External Tools Configuration..." eingestellt werden. OpenOCD wird mit Start-Parametern gestartet, z.B. "-f .\prj\arm-usb-ocd.cfg" für das Olimex JTAG Interface. Wenn man nun ein anderes JTAG Interface hat, so muss hier der Dateiname geändert und in das Projekt nach "prj\" muss die CFG-Datei einkopiert werden.

Mit Eclipase mit der grünen Käfertaste (Debug BlinkLED), der kleine Pfeil nach unten, "BlinkLED OpenOCD Reset Load Run" ausführen. Damit wird der GDB Debugger gestartet, das Projekt geladen und gestartet. Der Debugger beendet sich dann automatisch und die CPU läuft.

=== Weitere Plug-Ins für Eclipse ===
Damit das Arbeiten mit Eclipse einfacher wird, gibt es zahlreiche Plug-Ins. Diese können mittels Eclipse heruntergeladen werden und werden dann automatisch installiert.

Die in meinen Augen wichtigsten Plug-Ins sind folgende:
* ARM-Plug-In
* Register View
* GDB-Plug-In

Das ARM-PlugIn stellt einen Wizzard bereit, in dem projektspezifische Einstellungen über den Compiler, Linkerscript usw. mit Hilfe einer GUI getroffen werden können.

Register View ermöglicht das Einsehen der General-Purpose Registern im Mikrocontroller. Dies kann beim Debuggen Hilfreich sein, da man anhand des Stack-Registers evtl. Stack-Overflows erkennen kann.

GDB-PlugIn mittels dem GDB-PlugIn ist es über Eclipse möglich, sich auf einen GDB-Server zu Connecten. Dabei kann dann aus Eclipse heraus direkt der Code-Debuggt werden.

== Einrichten eines eigenen Projektes ==

== Einrichtung GDB-Server ==

Ein GDB-Server wird immer unter "External Tools Configuration..." eingerichtet.

[[bild:MenuExternalTool.png]]

Mit Hilfe dieser Funktion kann ein beliebiges Programm gestartet werden.

=== OpenOCD mit ARM-USB-OCD von Olimex ===

Der Aufruf, mit Parameter HW-Interface und Prozessor:

[[bild:MenuExternalToolOOCD1.png]]

Der Eintrag im Eclipse-Menü:

[[bild:MenuExternalToolOOCD2.png]]

Die restlichen Reiter sind ohne Änderung.

=== JLink mit Segger GDB-Server einrichten ===

Im Demo-Projekt ist eine Konfiguration für den Segger GDB-Server enthalten. Dabei wird der GDB-Server so gestartet dass SWD als Kommunikation genutzt wird.

Der Aufruf, mit Parameter für SWD (Single Wire Debug):

[[bild:MenuExternalToolJLink.png]]

Der Pfad zum "JLinkGDBServer.exe" muss so angepasst werden je nach dem wohin er installiert wurde.

=== Einrichtung ST-Link (SWD Programmer vom Eval Board) ===
==== Einrichtung unter Windows ====
==== Einrichtung unter Linux ====

!!! Achtung !!! Das ST-Link projekt für Linux ist mit den neueren 3.0.X Kernel nicht mehr lauffähig und lässt den gesamten Rechner einfrieren !!!
Sollte sich dort etwas ändern, so werde ich dies hier bekannt geben.

Vielfach wurde genannt, daß es schade sei, daß das Discoveryboard oder das STLink nur unter Windows benutzen zu können. Mittlerweile hat sich dieses geändert, ohne das, dass STLink mit einer neuen Firmware beschrieben werden muss. Es gibt eine kleine Gruppe, die einen STLink GDB-Server für Linux realisiert haben. Mittlerweile befindet sich dieses Projekt noch in der Beta-Phase, jedoch konnten die ersten Tests überzeugen.

Dazu muss der Sourcecode von der Seite [[https://github.com/whitequark/stlink/blob/master/src/stlink-hw.c Projekt-Seite]] mittels git gecloned werden. (GIT Link: https://github.com/whitequark/stlink.git)
Damit ein Compilieren des Sourcecodes funktioniert, muss mittels apt-get oä. folgendes Paket installiert werden:
<pre>libsgutils2-dev</pre>
Nachdem dieses Paket installiert wurde, muss im Sourcecode noch einige Änderungen durchgeführt werden, da dort "unsauber" gecasted wurde.
Dieses Bezieht sich auf die Datei: "stlink-hw.c" und dort in den Zeilen:
1420, 1491, 1514.
Dort muss ein explizieter Cast zu (unsigned int) durchgeführt werden, so dass in der Zeile 1420 statt:
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + off);</syntaxhighlight>
nun
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + (unsigned int)off);</syntaxhighlight> steht. Diese Änderung ist bei den beiden verbleibenden Zeilen durchzuführen.
Nachdem dies abgeschlossen wurde müssen die Sourcecodes mittels dem Befehl:
<pre> make -C build </pre>
compiliert werden.
Der Start dieses GDB-Servers wird durch die Kommandozeile initiiert:
<pre>./build/st-util <<PORT>> /dev/sg<<SG-NUMBER>> </pre>
Mittels des Attributes <<PORT>> wird die Port-Nummer des GDB-Servers angegeben. Die ST-Link "Geräte Datei" wird (zumindest bei mir) nicht immer an dem gleichen Pfaden angegeben.

Nach dem Start sollte folgende Meldung (beim Discoverboard) erscheinen:
<pre>
*** stlink_open [/dev/sg4] ***
Chip ID is 10016420.
Device connected: Medium-density value line device
Device parameters: SRAM: 0x2000 bytes, Flash: up to 0x20000 bytes in pages of 0x400 bytes
Flash size is 128 KiB.
Listening at *:1234...
</pre>
Nun ist der GDB-Server aktiv und kann mittels Eclipse genutzt werden. Für die Einrichtung von Eclipse siehe: Einrichtung unter Windows.

== Tipps, Tricks und Stolpersteine ==

* Die Dateiendung einer C/H Datei muss kleingeschrieben sein, denn sonst meint der GCC Compiler dass es C++ Dateien sind.

* Wird VBox benutzt und einen Filter für den ST-Link bzw. des USB-Devices des Discovery-Boards eingerichtet, so kommt es zu schwerwiegenden Konflikten bei dem nächsten Start von VBox. Das Problem ist die Seriennummer vom ST-Link, welche nicht sichtbare Zeichen enthält. Ein Workaround zu diesem Problem: In dem eingerichtetem Filter muss die Seriennummer entfernt werden.

== MicroXplorer - MCU graphical configuration tool ==

Der [http://www.st.com/web/en/catalog/tools/PF251717 MicroXplorer von ST] ist ein Eclipse Plugin (auch als standalone Version verfügbar) mit dem man sich die Peripheriefunktionen zusammen klicken kann die man beim STM32 Prozessor benötigt. Das Tool zeigt auch Kombinationen die nicht gehen. Somit kann man die Peripherie leichter planen.

Jedoch sollte man bei diesem Tool aufpassen: Wenn man z.B. zu erst CAN1 heraussucht und später FS_USB, so ist FS_USB nicht möglich. Wenn man das anders herum macht, so wird CAN1 auf alternative Pins gelegt und die Zuordnung klappt. Dennoch hilft es die Peripherie einfacher planen zu können.

== Weblinks, Foren, Communities ==
* Artikel [[STM32]]
* Artikel [[STM32 CooCox Installation]]
* [http://www.mikrocontroller.net/topic/214719 Thread zu diesem Thema]

[[Kategorie:STM32| ]]

STM32 Eclipse Installation

2014-01-24T08:05:27Z

Kichi: /* Installation von Eclipse unter Windows */

Dieser Artikel beschreibt, wie man Eclipse unter Windows installiert und für den Prozessor STM32 einrichtet, so dass ein Debuggen möglich ist.

== Installation von Eclipse unter Windows ==

'''Die Zusammenhänge:'''
* Eclipse - der Editor, ist eigentlich nichts weiteres als ein Editor, mit sehr viel Intelligenz
* Toolchain (make, Compiler, Linker, GDB, Bibliotheken, etc.). Hier gibt es verschiedene Möglichkeiten:
** YAGARTO GNU ARM toolchain - der Compiler und Debugger für Cortex-M3. Zusätzlich werden die Yagarto-Tools (make und sonstige Programme) benötigt.
** CodeSourcery - beinhaltet alle benötigten Tools, wie make, GCC, GDB, Newlib usw.
** GNU Tools for ARM Embedded Processors - benötigt zusätzlich ebenfalls make und rm bspw. aus den Yagarto-Tools
* CDT - Plugin, das Eclipse erweitert, sodaß C/C++ Programme editiert, kompiliert und gelinkt werden können. CDT steht für "C/C++ Development Tooling". Man kann Eclipse auch mit schon integrierten CDT auf der Eclipse Homepage bekommen.
* GDB Hardware Debugging - ein weiteres Eclipse-Plugin, welches notwendig ist, um mittels GDB und weiteren Tools Programme zu debuggen.
* GDB - der GNU Debugger, mit ihm ist es möglich, entsprechend kompilierte Programme auf C-Sourcelevel (und auch Assembler) zu debuggen. Er kann allerdings nicht direkt mit einem JTAG-Interface sprechen. Er "verbindet" sich dafür mit einem GDB-Server, der dann das JTAG-I/F anspricht.
* GDB-Server - stellt eine Verbindung mit GDB und dem JTAG-Interface her. Er führt die Kommandos des GDBs aus. Der Server muss vor dem debuggen gestartet werden, da GDB einen laufenden GDB-Server erwartet. Die Verbindung zwischen dem GDB und dem GDB-Server wird über eine TCP/IP Verbindung hergestellt.
** OpenOCD - ein freier GDB-Server
** Texane STlink - ebenfalls frei
* JTAG-Interface, z.B. Olimex ARM-USB-OCD, ST-Link oder diverse andere. Meist über USB an den PC angeschlossen, über ein JTAG-Kabel wird der Adapter mit der Prozessor-Platine verbunden. Der GDB-Server nimmt Kommandos vom GDB entgegen und führt diese über das JTAG-I/F des Prozessors aus.
* STM32-Prozessor, ja den braucht es auch noch, sonst gibt es nichts zu debuggen.

Es sieht zwar auf den ersten Blick etwas komplex aus, aber es ist dennoch logisch aufgebaut.

== Downloads ==

Die benötigten Dateien für Eclipse:

* [http://yagarto.de/ Yagarto-Tools http://yagarto.de/]
* [http://www.oracle.com/technetwork/java/javase/downloads/index.html Java JDK] Installation um Eclipse starten zu können.
* [http://eclipse.org/downloads/ Eclipse], der Download "Eclipse IDE for C/C++ Developers"
* [http://www.freddiechopin.info/ OpenOCD http://www.freddiechopin.info/] >> Download >> Software >> OpenOCD

''' Eclipse Demo-Projekt: '''

[[Media: Proj_Demo.zip | Blink-LED, komplettes Eclipse-Workspace von MmVisual]]
* Eclipse Workspace
* Mit OpenOCD und Dateien für den Olimex ARM-USB-OCD
* FW-Lib 3.4.0 von ST
* Start-Up Code als C-Datei, keine einzige Assembler-Datei
* Für STM32F103RB (128K Flash) wegen Initialisierung Stack-Pointer
* Nutzt make Tool, muss aber zu gmake umbenannt werden, ist weiter unten beschrieben

== Installation ==
=== Installation von Eclipse ===
Damit Eclipse gestartet werden kann, ist es nötig, dass zunächst Java installiert wird. Dabei muss einfach den Anweisungen des Installers gefolgt werden. Nachdem diese Installation abgeschlossen wurde, kann mit der Eclipse "Installation" fortgefahren werden.

Eclipse befindet sich (sofern im Download ausgewählt) in einem ZIP-Archiv. In diesem Archiv sind alle benötigten Dateien vorhanden, um Eclipse direkt starten zu können. Dieses ZIP-Archiv sollte dann zu C:\eclipse\ entpackt werden. In diesem Beispiel wird davon ausgegangen, dass eclipse zu den o.g. Pfad entpackt wird.

Sobald Eclipse vollständig entpackt wurde, kann eclipse gestartet werden. Während Eclipse startet, muss ein sog. Workspace ausgewählt werden. In diesem Workspace werden später alle Projekte und Sourcecodes abgelegt. Die Nachfolgende Grafik zeigt dieses Dialog-Fenster.
[[Datei:choose_workspace.png]]
Nachdem Eclipse erfolgreich gestartet werden kann, ist die Installation natürlich nicht abgeschlossen, da noch ein Compiler usw. für dem ARM-Mikrocontroller fehlt.

Für die Toolchain, sprich Compiler, newlib usw. hat man nun die Qual der Wahl, entweder man nimmt Yagarto-Tools oder Codesourcery. Der Unterschied zwischen den beiden toolchains ist nicht direkt erkennbar und soll an dieser Stelle nicht weiter behandelt werden. Ich verweise an dieser Stelle an den folgenden Foreneintrag:
[[http://www.mikrocontroller.net/topic/158503#1503836 Unterschied WinARM und Codesourcery]]

Ich persönlich habe mich für Codesourcery entschieden, da Truestuido von Atollic ebenfalls den none-eabi Compiler verwendet und dadurch die Linkerscripts direkt von Truestudio übernommen werden können.

=== Installation der Code-Sourcery Umgebung ===
Wer sich nun für die Code-Sourcery Umgebung entschieden hat, steht nun schon vor einem kleinerem Problem - Welche Version von Code-Sourcery soll man wählen?
Zur Auswahl stehen folgende Versionen:
* uCLinux
* EABI
* GNU/Linux
* SymbianOS
Hier ist die Wahl auf EABI beschränkt. Für weitere Hinweise siehe: [[http://www.codesourcery.com/sgpp/lite/arm/portal/doc9876/getting-started.pdf Codesourcery Getting-Started]]

Die Installation von Code-Sourcery ist komplett Menü geführt und entsprechend intuitiv durchzuführen. Dabei werden nachfolgend die wichtigsten Komponenten kurz erläutert:

CodeSourcery Common Startup Code Sequence
Diese vordefinierten Startup-Codes werden für den Start des Mikrocontrollers benutzt. Dabei wird der Stackpointer, die Interrupt-Handler usw. initialisiert. Die Benutzung dieser Startupcodes wird hier nicht näher Betrachtet, da STM vorgefertigte Startup-Codes kostenlos anbietet.

* CodeSourcery Debug Sprite for ARM
Die Debug-Sprite Umgebung ermöglicht das Debuggen eines Mikrocontrollers über JTAG. Debug-Sprite kann dabei über XML-Dateien konfiguriert werden. Jedoch kann Debug-Sprite nicht für das Debuggen von STM32-Mikrocontrollern verwendet werden.
GNU Binary Utilities (Binutils)
Die Binutils beinhaltet den GNU-Assembler sowie den für das Übersetzen eines C-Software-Modules benötigen Linker.

* GNU C Compiler (GCC)
Der GNU-C Compiler übersetzt den C-Code zu den sog. Object-Codes.

* GNU C++ Compiler (G++)
Der G++ Compiler übersetzt ein C++-Software-Modul zu Object-Codes, um damit die Verwendung von C++ auf einem Mikrocontroller zu ermöglichen.

* GNU C++ Runtime Library (Libstdc++)
Diese Library stellt C++ spezifische Funktionen zu Verfügung.

* GNU Debugger (GDB)
Der Debugger ist der GDB-Client, der für das Debuggen eines Software-Moduls genutzt wird.

* Newlib C Library

Die Newlib stellt die std-Lib für einen Mikrocontroller zu Verfügung. Dabei ist zu beachten, das die Newlib syscalls und stubs nutzt, um so eine Betriebssystemunabhängige Benutzung zu ermöglichen. Dies ermöglicht die Benutzung der Newlib auf einem Bare-Metal-System und auf einem uC-Linux basiertem Software-Modul.

Ich persönlich habe als Installationsverzeichnis C:\WinARM benutzt, damit die entsprechenden Pfade zu bestimmten binaris keine großartigen Sonderzeichen aufweisen.

=== Installation der Yagarto Umgebung ===
Die Installation sollte so ausgeführt werden, dass alles nach "C:\WinARM\" installiert wird, dazu müssen in den Setup-Paketen während des Setups immer die Pfade "C:\Programme\" angepasst werden. Damit kann man die gesamte Entwicklung und Konfiguration einfach sichern als ZIP Datei und sogar bei einem zweiten Rechner wieder einspielen.

Zu erst werden die Downloads von Yagarto geladen und installiert. Dort ist auch sehr gut beschrieben wie das Einrichten geht.
Allerdings fehlt auf der Yagarto-Seite der Hinweis auf den Download-Link des eigentlichen Eclipse Programms, daher ist er oben im Artikel aufgeführt.

Wenn man diese [http://yagarto.de/howto/yagarto2/index.html#download Yagarto-Anleitung] abgeschlossen hat kommt die Einrichtung von OpenOCD.
Eine Debugger-Einrichtung ist bei [http://yagarto.de/howto/yagarto2/index.html#cbug Yagarto] auch beschrieben, allerdings nicht für den STM32 Prozessor.

Nach der Installation von Yagarto-Tools muss eine Datei geändert werden:
C:\WinARM\yagarto-tools\bin\make.exe muss nach gmake.exe umbenannt werden.
Grund: Wenn man Delphi installiert hat, dann würde Eclipse das make Tool von Delphi finden und man kann das Eclipse Projekt nicht kompilieren.
Das Demo-Projekt nutzt auch das "gmake.exe".
Alternativ kann auch make.exe kopiert zu gmake.exe werden, wenn man kein Delphi installiert hat.

==== Start mit dem Demo-Projekt ====

Für alle Projekte habe ich das Verzeichnis C:\WinARM\Projekt\ vorgesehen, damit ist immer alles zusammen. Nun entpackt man das Demo-Projekt nach C:\WinARM\Projekt\ somit müsste dort ein neues Unterverzeichnis "Proj_Demo" vorhanden sein samt allen unterordnern.

Nun Eclipse Öffnen. Menü "File" >> "Switch Workspace" >> "Other...". In der Eingabezeile "Workspace:" wird nun das Verzeichnis "C:\WinARM\Projekt\Proj_Demo" eingegeben. Mit OK wird sich Eclipse beenden und neu starten.

Links im Baum sieht man das Projekt "BlinkLED":
* inc: die eigenen Includes
* lib: die FW-Lib von ST
* out: die kompilierten Dateien und listings
* prj: OpenOCD und LD Linker-Datei
* src: die eigenen Quellcodes
* makefile

Das Projekt wurde geschrieben für den STM32F103RC (256K Flash/48K RAM), läuft aber auch mit einem STM32F103xB da der Stack-Pointer auf 20K initialisiert wird. Details stehen in der Datei "src/stm32f10x_vector.c", Zeile 29,30:
<syntaxhighlight lang="c">#define STACK_TOP (0x20005000 - 4)
//#define STACK_TOP (0x2000C000 - 4)</syntaxhighlight>
Damit wird der Stack-Pointer für den RAM im Chip initialisiert.

Zum kompilieren rechten Mausklick auf das Projekt (normalerweise links im Navigator oder Projekt-Explorer) und dann im aufgehenden Kontextmenu auf "Build" klicken.
Mit Strg+B wird nicht nur das Projekt neu kompiliert sondern ALLE Projekte im aktuellen Workspace gerade offen sind. Wenn man dort nur ein Projekt hat geht auch CTRL-B.

''' Die Funktionen des Demo-Projekts '''
* Blink-LED auf Prot A.0, Port C.7, PortD.3,4,7,13 (STM3210C-EVAL Board)
* Initialisieren aller Variablen
* Initialisieren Clock auf HSI, 8MHz
* Initialisieren IO-Pins der LED's
* Initialisieren Timer für Systick
* Main-Schleife in der die Timer-Variablen gesetzt und die LED's ausgegeben werden
* Debug-Helper, siehe "src\DebugHelper.c"
* Systick-Interrupt
* komplett in C programmiert, kein Assembler
* ST FW-Lib V3.4.0 wird für alle Funktionen genutzt

'''Erster Start mit dem Demo-Projekt'''

Mit Eclipse mit der grünen Play-Taste mit dem roten Koffer "Run OpenOCD BlinkLED" "OpenOCD BlinkLED starten. Damit wird der GDB Server OpenOCD mit dem JTAG-Key ARM-USB-OCD gestartet. Wenn man einen anderen JTAG Adapter hat, so kann der mit dem kleinen schwarzen Pfeil im Menü "External Tools Configuration..." eingestellt werden. OpenOCD wird mit Start-Parametern gestartet, z.B. "-f .\prj\arm-usb-ocd.cfg" für das Olimex JTAG Interface. Wenn man nun ein anderes JTAG Interface hat, so muss hier der Dateiname geändert und in das Projekt nach "prj\" muss die CFG-Datei einkopiert werden.

Mit Eclipase mit der grünen Käfertaste (Debug BlinkLED), der kleine Pfeil nach unten, "BlinkLED OpenOCD Reset Load Run" ausführen. Damit wird der GDB Debugger gestartet, das Projekt geladen und gestartet. Der Debugger beendet sich dann automatisch und die CPU läuft.

=== Weitere Plug-Ins für Eclipse ===
Damit das Arbeiten mit Eclipse einfacher wird, gibt es zahlreiche Plug-Ins. Diese können mittels Eclipse heruntergeladen werden und werden dann automatisch installiert.

Die in meinen Augen wichtigsten Plug-Ins sind folgende:
* ARM-Plug-In
* Register View
* GDB-Plug-In

Das ARM-PlugIn stellt einen Wizzard bereit, in dem projektspezifische Einstellungen über den Compiler, Linkerscript usw. mit Hilfe einer GUI getroffen werden können.

Register View ermöglicht das Einsehen der General-Purpose Registern im Mikrocontroller. Dies kann beim Debuggen Hilfreich sein, da man anhand des Stack-Registers evtl. Stack-Overflows erkennen kann.

GDB-PlugIn mittels dem GDB-PlugIn ist es über Eclipse möglich, sich auf einen GDB-Server zu Connecten. Dabei kann dann aus Eclipse heraus direkt der Code-Debuggt werden.

== Einrichten eines eigenen Projektes ==

== Einrichtung GDB-Server ==

Ein GDB-Server wird immer unter "External Tools Configuration..." eingerichtet.

[[bild:MenuExternalTool.png]]

Mit Hilfe dieser Funktion kann ein beliebiges Programm gestartet werden.

=== OpenOCD mit ARM-USB-OCD von Olimex ===

Der Aufruf, mit Parameter HW-Interface und Prozessor:

[[bild:MenuExternalToolOOCD1.png]]

Der Eintrag im Eclipse-Menü:

[[bild:MenuExternalToolOOCD2.png]]

Die restlichen Reiter sind ohne Änderung.

=== JLink mit Segger GDB-Server einrichten ===

Im Demo-Projekt ist eine Konfiguration für den Segger GDB-Server enthalten. Dabei wird der GDB-Server so gestartet dass SWD als Kommunikation genutzt wird.

Der Aufruf, mit Parameter für SWD (Single Wire Debug):

[[bild:MenuExternalToolJLink.png]]

Der Pfad zum "JLinkGDBServer.exe" muss so angepasst werden je nach dem wohin er installiert wurde.

=== Einrichtung ST-Link (SWD Programmer vom Eval Board) ===
==== Einrichtung unter Windows ====
==== Einrichtung unter Linux ====

!!! Achtung !!! Das ST-Link projekt für Linux ist mit den neueren 3.0.X Kernel nicht mehr lauffähig und lässt den gesamten Rechner einfrieren !!!
Sollte sich dort etwas ändern, so werde ich dies hier bekannt geben.

Vielfach wurde genannt, daß es schade sei, daß das Discoveryboard oder das STLink nur unter Windows benutzen zu können. Mittlerweile hat sich dieses geändert, ohne das, dass STLink mit einer neuen Firmware beschrieben werden muss. Es gibt eine kleine Gruppe, die einen STLink GDB-Server für Linux realisiert haben. Mittlerweile befindet sich dieses Projekt noch in der Beta-Phase, jedoch konnten die ersten Tests überzeugen.

Dazu muss der Sourcecode von der Seite [[https://github.com/whitequark/stlink/blob/master/src/stlink-hw.c Projekt-Seite]] mittels git gecloned werden. (GIT Link: https://github.com/whitequark/stlink.git)
Damit ein Compilieren des Sourcecodes funktioniert, muss mittels apt-get oä. folgendes Paket installiert werden:
<pre>libsgutils2-dev</pre>
Nachdem dieses Paket installiert wurde, muss im Sourcecode noch einige Änderungen durchgeführt werden, da dort "unsauber" gecasted wurde.
Dieses Bezieht sich auf die Datei: "stlink-hw.c" und dort in den Zeilen:
1420, 1491, 1514.
Dort muss ein explizieter Cast zu (unsigned int) durchgeführt werden, so dass in der Zeile 1420 statt:
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + off);</syntaxhighlight>
nun
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + (unsigned int)off);</syntaxhighlight> steht. Diese Änderung ist bei den beiden verbleibenden Zeilen durchzuführen.
Nachdem dies abgeschlossen wurde müssen die Sourcecodes mittels dem Befehl:
<pre> make -C build </pre>
compiliert werden.
Der Start dieses GDB-Servers wird durch die Kommandozeile initiiert:
<pre>./build/st-util <<PORT>> /dev/sg<<SG-NUMBER>> </pre>
Mittels des Attributes <<PORT>> wird die Port-Nummer des GDB-Servers angegeben. Die ST-Link "Geräte Datei" wird (zumindest bei mir) nicht immer an dem gleichen Pfaden angegeben.

Nach dem Start sollte folgende Meldung (beim Discoverboard) erscheinen:
<pre>
*** stlink_open [/dev/sg4] ***
Chip ID is 10016420.
Device connected: Medium-density value line device
Device parameters: SRAM: 0x2000 bytes, Flash: up to 0x20000 bytes in pages of 0x400 bytes
Flash size is 128 KiB.
Listening at *:1234...
</pre>
Nun ist der GDB-Server aktiv und kann mittels Eclipse genutzt werden. Für die Einrichtung von Eclipse siehe: Einrichtung unter Windows.

== Tipps, Tricks und Stolpersteine ==

* Die Dateiendung einer C/H Datei muss kleingeschrieben sein, denn sonst meint der GCC Compiler dass es C++ Dateien sind.

* Wird VBox benutzt und einen Filter für den ST-Link bzw. des USB-Devices des Discovery-Boards eingerichtet, so kommt es zu schwerwiegenden Konflikten bei dem nächsten Start von VBox. Das Problem ist die Seriennummer vom ST-Link, welche nicht sichtbare Zeichen enthält. Ein Workaround zu diesem Problem: In dem eingerichtetem Filter muss die Seriennummer entfernt werden.

== MicroXplorer - MCU graphical configuration tool ==

Der [http://www.st.com/web/en/catalog/tools/PF251717 MicroXplorer von ST] ist ein Eclipse Plugin mit dem man sich die Peripheriefunktionen zusammen klicken kann die man beim STM32 Prozessor benötigt. Das Tool zeigt auch Kombinationen die nicht gehen. Somit kann man die Peripherie leichter planen.

Jedoch sollte man bei diesem Tool aufpassen: Wenn man z.B. zu erst CAN1 heraussucht und später FS_USB, so ist FS_USB nicht möglich. Wenn man das anders herum macht, so wird CAN1 auf alternative Pins gelegt und die Zuordnung klappt. Dennoch hilft es die Peripherie einfacher planen zu können.

== Weblinks, Foren, Communities ==
* Artikel [[STM32]]
* Artikel [[STM32 CooCox Installation]]
* [http://www.mikrocontroller.net/topic/214719 Thread zu diesem Thema]

[[Kategorie:STM32| ]]

STM32 Eclipse Installation

2014-01-24T08:05:14Z

Kichi: /* Installation von Eclipse unter Windows */

Dieser Artikel beschreibt, wie man Eclipse unter Windows installiert und für den Prozessor STM32 einrichtet, so dass ein Debuggen möglich ist.

== Installation von Eclipse unter Windows ==

'''Die Zusammenhänge:'''
* Eclipse - der Editor, ist eigentlich nichts weiteres als ein Editor, mit sehr viel Intelligenz
* Toolchain (make, Compiler, Linker, GDB, Bibliotheken, etc.). Hier gibt es verschiedene Möglichkeiten:
** YAGARTO GNU ARM toolchain - der Compiler und Debugger für Cortex-M3. Zusätzlich werden die Yagarto-Tools (make und sonstige Programme) benötigt.
** CodeSourcery - beinhaltet alle benötigten Tools, wie make, GCC, GDB, Newlib usw.
** GNU Tools for ARM Embedded Processors - benötigt zusätzlich ebenfalls make und rm bspw. aus den Yagarto-Tools
* CDT - Plugin, das Eclipse erweitert, sodaß C/C++ Programme editiert, kompiliert und gelinkt werden können. CDT steht für "C/C++ Development Tooling". Man kann Eclipse auch mit schon integrierten CDT auf der Eclipse Homepage bekommen.
* GDB Hardware Debugging - ein weiteres Eclipse-Plugin, welches notwendig ist, um mittels GDB und weiteren Tools Programme zu debuggen.
* GDB - der GNU Debugger, mit ihm ist es möglich, entsprechend kompilierte Programme auf C-Sourcelevel (und auch Assembler) zu debuggen. Er kann allerdings nicht direkt mit einem JTAG-Interface sprechen. Er "verbindet" sich dafür mit einem GDB-Server, der dann das JTAG-I/F anspricht.
* GDB-Server - stellt Verbindung mit GDB und dem JTAG-Interface her. Er führt die Kommandos des GDBs aus. Der Server muss vor dem debuggen gestartet werden, da GDB einen laufenden GDB-Server erwartet. Die Verbindung zwischen dem GDB und dem GDB-Server wird über eine TCP/IP Verbindung hergestellt.
** OpenOCD - ein freier GDB-Server
** Texane STlink - ebenfalls frei
* JTAG-Interface, z.B. Olimex ARM-USB-OCD, ST-Link oder diverse andere. Meist über USB an den PC angeschlossen, über ein JTAG-Kabel wird der Adapter mit der Prozessor-Platine verbunden. Der GDB-Server nimmt Kommandos vom GDB entgegen und führt diese über das JTAG-I/F des Prozessors aus.
* STM32-Prozessor, ja den braucht es auch noch, sonst gibt es nichts zu debuggen.

Es sieht zwar auf den ersten Blick etwas komplex aus, aber es ist dennoch logisch aufgebaut.

== Downloads ==

Die benötigten Dateien für Eclipse:

* [http://yagarto.de/ Yagarto-Tools http://yagarto.de/]
* [http://www.oracle.com/technetwork/java/javase/downloads/index.html Java JDK] Installation um Eclipse starten zu können.
* [http://eclipse.org/downloads/ Eclipse], der Download "Eclipse IDE for C/C++ Developers"
* [http://www.freddiechopin.info/ OpenOCD http://www.freddiechopin.info/] >> Download >> Software >> OpenOCD

''' Eclipse Demo-Projekt: '''

[[Media: Proj_Demo.zip | Blink-LED, komplettes Eclipse-Workspace von MmVisual]]
* Eclipse Workspace
* Mit OpenOCD und Dateien für den Olimex ARM-USB-OCD
* FW-Lib 3.4.0 von ST
* Start-Up Code als C-Datei, keine einzige Assembler-Datei
* Für STM32F103RB (128K Flash) wegen Initialisierung Stack-Pointer
* Nutzt make Tool, muss aber zu gmake umbenannt werden, ist weiter unten beschrieben

== Installation ==
=== Installation von Eclipse ===
Damit Eclipse gestartet werden kann, ist es nötig, dass zunächst Java installiert wird. Dabei muss einfach den Anweisungen des Installers gefolgt werden. Nachdem diese Installation abgeschlossen wurde, kann mit der Eclipse "Installation" fortgefahren werden.

Eclipse befindet sich (sofern im Download ausgewählt) in einem ZIP-Archiv. In diesem Archiv sind alle benötigten Dateien vorhanden, um Eclipse direkt starten zu können. Dieses ZIP-Archiv sollte dann zu C:\eclipse\ entpackt werden. In diesem Beispiel wird davon ausgegangen, dass eclipse zu den o.g. Pfad entpackt wird.

Sobald Eclipse vollständig entpackt wurde, kann eclipse gestartet werden. Während Eclipse startet, muss ein sog. Workspace ausgewählt werden. In diesem Workspace werden später alle Projekte und Sourcecodes abgelegt. Die Nachfolgende Grafik zeigt dieses Dialog-Fenster.
[[Datei:choose_workspace.png]]
Nachdem Eclipse erfolgreich gestartet werden kann, ist die Installation natürlich nicht abgeschlossen, da noch ein Compiler usw. für dem ARM-Mikrocontroller fehlt.

Für die Toolchain, sprich Compiler, newlib usw. hat man nun die Qual der Wahl, entweder man nimmt Yagarto-Tools oder Codesourcery. Der Unterschied zwischen den beiden toolchains ist nicht direkt erkennbar und soll an dieser Stelle nicht weiter behandelt werden. Ich verweise an dieser Stelle an den folgenden Foreneintrag:
[[http://www.mikrocontroller.net/topic/158503#1503836 Unterschied WinARM und Codesourcery]]

Ich persönlich habe mich für Codesourcery entschieden, da Truestuido von Atollic ebenfalls den none-eabi Compiler verwendet und dadurch die Linkerscripts direkt von Truestudio übernommen werden können.

=== Installation der Code-Sourcery Umgebung ===
Wer sich nun für die Code-Sourcery Umgebung entschieden hat, steht nun schon vor einem kleinerem Problem - Welche Version von Code-Sourcery soll man wählen?
Zur Auswahl stehen folgende Versionen:
* uCLinux
* EABI
* GNU/Linux
* SymbianOS
Hier ist die Wahl auf EABI beschränkt. Für weitere Hinweise siehe: [[http://www.codesourcery.com/sgpp/lite/arm/portal/doc9876/getting-started.pdf Codesourcery Getting-Started]]

Die Installation von Code-Sourcery ist komplett Menü geführt und entsprechend intuitiv durchzuführen. Dabei werden nachfolgend die wichtigsten Komponenten kurz erläutert:

CodeSourcery Common Startup Code Sequence
Diese vordefinierten Startup-Codes werden für den Start des Mikrocontrollers benutzt. Dabei wird der Stackpointer, die Interrupt-Handler usw. initialisiert. Die Benutzung dieser Startupcodes wird hier nicht näher Betrachtet, da STM vorgefertigte Startup-Codes kostenlos anbietet.

* CodeSourcery Debug Sprite for ARM
Die Debug-Sprite Umgebung ermöglicht das Debuggen eines Mikrocontrollers über JTAG. Debug-Sprite kann dabei über XML-Dateien konfiguriert werden. Jedoch kann Debug-Sprite nicht für das Debuggen von STM32-Mikrocontrollern verwendet werden.
GNU Binary Utilities (Binutils)
Die Binutils beinhaltet den GNU-Assembler sowie den für das Übersetzen eines C-Software-Modules benötigen Linker.

* GNU C Compiler (GCC)
Der GNU-C Compiler übersetzt den C-Code zu den sog. Object-Codes.

* GNU C++ Compiler (G++)
Der G++ Compiler übersetzt ein C++-Software-Modul zu Object-Codes, um damit die Verwendung von C++ auf einem Mikrocontroller zu ermöglichen.

* GNU C++ Runtime Library (Libstdc++)
Diese Library stellt C++ spezifische Funktionen zu Verfügung.

* GNU Debugger (GDB)
Der Debugger ist der GDB-Client, der für das Debuggen eines Software-Moduls genutzt wird.

* Newlib C Library

Die Newlib stellt die std-Lib für einen Mikrocontroller zu Verfügung. Dabei ist zu beachten, das die Newlib syscalls und stubs nutzt, um so eine Betriebssystemunabhängige Benutzung zu ermöglichen. Dies ermöglicht die Benutzung der Newlib auf einem Bare-Metal-System und auf einem uC-Linux basiertem Software-Modul.

Ich persönlich habe als Installationsverzeichnis C:\WinARM benutzt, damit die entsprechenden Pfade zu bestimmten binaris keine großartigen Sonderzeichen aufweisen.

=== Installation der Yagarto Umgebung ===
Die Installation sollte so ausgeführt werden, dass alles nach "C:\WinARM\" installiert wird, dazu müssen in den Setup-Paketen während des Setups immer die Pfade "C:\Programme\" angepasst werden. Damit kann man die gesamte Entwicklung und Konfiguration einfach sichern als ZIP Datei und sogar bei einem zweiten Rechner wieder einspielen.

Zu erst werden die Downloads von Yagarto geladen und installiert. Dort ist auch sehr gut beschrieben wie das Einrichten geht.
Allerdings fehlt auf der Yagarto-Seite der Hinweis auf den Download-Link des eigentlichen Eclipse Programms, daher ist er oben im Artikel aufgeführt.

Wenn man diese [http://yagarto.de/howto/yagarto2/index.html#download Yagarto-Anleitung] abgeschlossen hat kommt die Einrichtung von OpenOCD.
Eine Debugger-Einrichtung ist bei [http://yagarto.de/howto/yagarto2/index.html#cbug Yagarto] auch beschrieben, allerdings nicht für den STM32 Prozessor.

Nach der Installation von Yagarto-Tools muss eine Datei geändert werden:
C:\WinARM\yagarto-tools\bin\make.exe muss nach gmake.exe umbenannt werden.
Grund: Wenn man Delphi installiert hat, dann würde Eclipse das make Tool von Delphi finden und man kann das Eclipse Projekt nicht kompilieren.
Das Demo-Projekt nutzt auch das "gmake.exe".
Alternativ kann auch make.exe kopiert zu gmake.exe werden, wenn man kein Delphi installiert hat.

==== Start mit dem Demo-Projekt ====

Für alle Projekte habe ich das Verzeichnis C:\WinARM\Projekt\ vorgesehen, damit ist immer alles zusammen. Nun entpackt man das Demo-Projekt nach C:\WinARM\Projekt\ somit müsste dort ein neues Unterverzeichnis "Proj_Demo" vorhanden sein samt allen unterordnern.

Nun Eclipse Öffnen. Menü "File" >> "Switch Workspace" >> "Other...". In der Eingabezeile "Workspace:" wird nun das Verzeichnis "C:\WinARM\Projekt\Proj_Demo" eingegeben. Mit OK wird sich Eclipse beenden und neu starten.

Links im Baum sieht man das Projekt "BlinkLED":
* inc: die eigenen Includes
* lib: die FW-Lib von ST
* out: die kompilierten Dateien und listings
* prj: OpenOCD und LD Linker-Datei
* src: die eigenen Quellcodes
* makefile

Das Projekt wurde geschrieben für den STM32F103RC (256K Flash/48K RAM), läuft aber auch mit einem STM32F103xB da der Stack-Pointer auf 20K initialisiert wird. Details stehen in der Datei "src/stm32f10x_vector.c", Zeile 29,30:
<syntaxhighlight lang="c">#define STACK_TOP (0x20005000 - 4)
//#define STACK_TOP (0x2000C000 - 4)</syntaxhighlight>
Damit wird der Stack-Pointer für den RAM im Chip initialisiert.

Zum kompilieren rechten Mausklick auf das Projekt (normalerweise links im Navigator oder Projekt-Explorer) und dann im aufgehenden Kontextmenu auf "Build" klicken.
Mit Strg+B wird nicht nur das Projekt neu kompiliert sondern ALLE Projekte im aktuellen Workspace gerade offen sind. Wenn man dort nur ein Projekt hat geht auch CTRL-B.

''' Die Funktionen des Demo-Projekts '''
* Blink-LED auf Prot A.0, Port C.7, PortD.3,4,7,13 (STM3210C-EVAL Board)
* Initialisieren aller Variablen
* Initialisieren Clock auf HSI, 8MHz
* Initialisieren IO-Pins der LED's
* Initialisieren Timer für Systick
* Main-Schleife in der die Timer-Variablen gesetzt und die LED's ausgegeben werden
* Debug-Helper, siehe "src\DebugHelper.c"
* Systick-Interrupt
* komplett in C programmiert, kein Assembler
* ST FW-Lib V3.4.0 wird für alle Funktionen genutzt

'''Erster Start mit dem Demo-Projekt'''

Mit Eclipse mit der grünen Play-Taste mit dem roten Koffer "Run OpenOCD BlinkLED" "OpenOCD BlinkLED starten. Damit wird der GDB Server OpenOCD mit dem JTAG-Key ARM-USB-OCD gestartet. Wenn man einen anderen JTAG Adapter hat, so kann der mit dem kleinen schwarzen Pfeil im Menü "External Tools Configuration..." eingestellt werden. OpenOCD wird mit Start-Parametern gestartet, z.B. "-f .\prj\arm-usb-ocd.cfg" für das Olimex JTAG Interface. Wenn man nun ein anderes JTAG Interface hat, so muss hier der Dateiname geändert und in das Projekt nach "prj\" muss die CFG-Datei einkopiert werden.

Mit Eclipase mit der grünen Käfertaste (Debug BlinkLED), der kleine Pfeil nach unten, "BlinkLED OpenOCD Reset Load Run" ausführen. Damit wird der GDB Debugger gestartet, das Projekt geladen und gestartet. Der Debugger beendet sich dann automatisch und die CPU läuft.

=== Weitere Plug-Ins für Eclipse ===
Damit das Arbeiten mit Eclipse einfacher wird, gibt es zahlreiche Plug-Ins. Diese können mittels Eclipse heruntergeladen werden und werden dann automatisch installiert.

Die in meinen Augen wichtigsten Plug-Ins sind folgende:
* ARM-Plug-In
* Register View
* GDB-Plug-In

Das ARM-PlugIn stellt einen Wizzard bereit, in dem projektspezifische Einstellungen über den Compiler, Linkerscript usw. mit Hilfe einer GUI getroffen werden können.

Register View ermöglicht das Einsehen der General-Purpose Registern im Mikrocontroller. Dies kann beim Debuggen Hilfreich sein, da man anhand des Stack-Registers evtl. Stack-Overflows erkennen kann.

GDB-PlugIn mittels dem GDB-PlugIn ist es über Eclipse möglich, sich auf einen GDB-Server zu Connecten. Dabei kann dann aus Eclipse heraus direkt der Code-Debuggt werden.

== Einrichten eines eigenen Projektes ==

== Einrichtung GDB-Server ==

Ein GDB-Server wird immer unter "External Tools Configuration..." eingerichtet.

[[bild:MenuExternalTool.png]]

Mit Hilfe dieser Funktion kann ein beliebiges Programm gestartet werden.

=== OpenOCD mit ARM-USB-OCD von Olimex ===

Der Aufruf, mit Parameter HW-Interface und Prozessor:

[[bild:MenuExternalToolOOCD1.png]]

Der Eintrag im Eclipse-Menü:

[[bild:MenuExternalToolOOCD2.png]]

Die restlichen Reiter sind ohne Änderung.

=== JLink mit Segger GDB-Server einrichten ===

Im Demo-Projekt ist eine Konfiguration für den Segger GDB-Server enthalten. Dabei wird der GDB-Server so gestartet dass SWD als Kommunikation genutzt wird.

Der Aufruf, mit Parameter für SWD (Single Wire Debug):

[[bild:MenuExternalToolJLink.png]]

Der Pfad zum "JLinkGDBServer.exe" muss so angepasst werden je nach dem wohin er installiert wurde.

=== Einrichtung ST-Link (SWD Programmer vom Eval Board) ===
==== Einrichtung unter Windows ====
==== Einrichtung unter Linux ====

!!! Achtung !!! Das ST-Link projekt für Linux ist mit den neueren 3.0.X Kernel nicht mehr lauffähig und lässt den gesamten Rechner einfrieren !!!
Sollte sich dort etwas ändern, so werde ich dies hier bekannt geben.

Vielfach wurde genannt, daß es schade sei, daß das Discoveryboard oder das STLink nur unter Windows benutzen zu können. Mittlerweile hat sich dieses geändert, ohne das, dass STLink mit einer neuen Firmware beschrieben werden muss. Es gibt eine kleine Gruppe, die einen STLink GDB-Server für Linux realisiert haben. Mittlerweile befindet sich dieses Projekt noch in der Beta-Phase, jedoch konnten die ersten Tests überzeugen.

Dazu muss der Sourcecode von der Seite [[https://github.com/whitequark/stlink/blob/master/src/stlink-hw.c Projekt-Seite]] mittels git gecloned werden. (GIT Link: https://github.com/whitequark/stlink.git)
Damit ein Compilieren des Sourcecodes funktioniert, muss mittels apt-get oä. folgendes Paket installiert werden:
<pre>libsgutils2-dev</pre>
Nachdem dieses Paket installiert wurde, muss im Sourcecode noch einige Änderungen durchgeführt werden, da dort "unsauber" gecasted wurde.
Dieses Bezieht sich auf die Datei: "stlink-hw.c" und dort in den Zeilen:
1420, 1491, 1514.
Dort muss ein explizieter Cast zu (unsigned int) durchgeführt werden, so dass in der Zeile 1420 statt:
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + off);</syntaxhighlight>
nun
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + (unsigned int)off);</syntaxhighlight> steht. Diese Änderung ist bei den beiden verbleibenden Zeilen durchzuführen.
Nachdem dies abgeschlossen wurde müssen die Sourcecodes mittels dem Befehl:
<pre> make -C build </pre>
compiliert werden.
Der Start dieses GDB-Servers wird durch die Kommandozeile initiiert:
<pre>./build/st-util <<PORT>> /dev/sg<<SG-NUMBER>> </pre>
Mittels des Attributes <<PORT>> wird die Port-Nummer des GDB-Servers angegeben. Die ST-Link "Geräte Datei" wird (zumindest bei mir) nicht immer an dem gleichen Pfaden angegeben.

Nach dem Start sollte folgende Meldung (beim Discoverboard) erscheinen:
<pre>
*** stlink_open [/dev/sg4] ***
Chip ID is 10016420.
Device connected: Medium-density value line device
Device parameters: SRAM: 0x2000 bytes, Flash: up to 0x20000 bytes in pages of 0x400 bytes
Flash size is 128 KiB.
Listening at *:1234...
</pre>
Nun ist der GDB-Server aktiv und kann mittels Eclipse genutzt werden. Für die Einrichtung von Eclipse siehe: Einrichtung unter Windows.

== Tipps, Tricks und Stolpersteine ==

* Die Dateiendung einer C/H Datei muss kleingeschrieben sein, denn sonst meint der GCC Compiler dass es C++ Dateien sind.

* Wird VBox benutzt und einen Filter für den ST-Link bzw. des USB-Devices des Discovery-Boards eingerichtet, so kommt es zu schwerwiegenden Konflikten bei dem nächsten Start von VBox. Das Problem ist die Seriennummer vom ST-Link, welche nicht sichtbare Zeichen enthält. Ein Workaround zu diesem Problem: In dem eingerichtetem Filter muss die Seriennummer entfernt werden.

== MicroXplorer - MCU graphical configuration tool ==

Der [http://www.st.com/web/en/catalog/tools/PF251717 MicroXplorer von ST] ist ein Eclipse Plugin mit dem man sich die Peripheriefunktionen zusammen klicken kann die man beim STM32 Prozessor benötigt. Das Tool zeigt auch Kombinationen die nicht gehen. Somit kann man die Peripherie leichter planen.

Jedoch sollte man bei diesem Tool aufpassen: Wenn man z.B. zu erst CAN1 heraussucht und später FS_USB, so ist FS_USB nicht möglich. Wenn man das anders herum macht, so wird CAN1 auf alternative Pins gelegt und die Zuordnung klappt. Dennoch hilft es die Peripherie einfacher planen zu können.

== Weblinks, Foren, Communities ==
* Artikel [[STM32]]
* Artikel [[STM32 CooCox Installation]]
* [http://www.mikrocontroller.net/topic/214719 Thread zu diesem Thema]

[[Kategorie:STM32| ]]

STM32 Eclipse Installation

2014-01-24T08:04:50Z

Kichi: /* Installation von Eclipse unter Windows */

Dieser Artikel beschreibt, wie man Eclipse unter Windows installiert und für den Prozessor STM32 einrichtet, so dass ein Debuggen möglich ist.

== Installation von Eclipse unter Windows ==

'''Die Zusammenhänge:'''
* Eclipse - der Editor, ist eigentlich nichts weiteres als ein Editor, mit sehr viel Intelligenz
* Toolchain (make, Compiler, Linker, GDB, Bibliotheken, etc.). Hier gibt es verschiedene Möglichkeiten:
** YAGARTO GNU ARM toolchain - der Compiler und Debugger für Cortex-M3. Zusätzlich werden die Yagarto-Tools (make und sonstige Programme) benötigt.
** CodeSourcery - beinhaltet alle benötigten Tools, wie make, GCC, GDB, Newlib usw.
** GNU Tools for ARM Embedded Processors - benötigt zusätzlich ebenfalls make und rm bspw. aus den Yagarto-Tools
* CDT - Plugin, das Eclipse erweitert, sodaß C/C++ Programme editiert, kompiliert und gelinkt werden können. CDT steht für "C/C++ Development Tooling". Man kann Eclipse auch mit schon integrierten CDT auf der Eclipse Homepage bekommen.
* GDB Hardware Debugging - ein weiteres Eclipse-Plugin, welches notwendig ist, um mittels GDB und weiteren Tools Programme zu debuggen.
* GDB - der GNU Debugger, mit ihm ist es möglich, entsprechend kompilierte Programme auf C-Sourcelevel (und auch Assembler) zu debuggen. Er kann allerdings nicht direkt mit einem JTAG-Interface sprechen. Er "verbindet" sich dafür mit einem GDB-Server, der dann das JTAG-I/F anspricht.
* GDB-Server stellt Verbindung mit GDB und dem JTAG-Interface her. Er führt die Kommandos des GDBs aus. Der Server muss vor dem debuggen gestartet werden, da GDB einen laufenden GDB-Server erwartet. Die Verbindung zwischen dem GDB und dem GDB-Server wird über eine TCP/IP Verbindung hergestellt.
** OpenOCD - ein freier GDB-Server
** Texane STlink - ebenfalls frei
* JTAG-Interface, z.B. Olimex ARM-USB-OCD, ST-Link oder diverse andere. Meist über USB an den PC angeschlossen, über ein JTAG-Kabel wird der Adapter mit der Prozessor-Platine verbunden. Der GDB-Server nimmt Kommandos vom GDB entgegen und führt diese über das JTAG-I/F des Prozessors aus.
* STM32-Prozessor, ja den braucht es auch noch, sonst gibt es nichts zu debuggen.

Es sieht zwar auf den ersten Blick etwas komplex aus, aber es ist dennoch logisch aufgebaut.

== Downloads ==

Die benötigten Dateien für Eclipse:

* [http://yagarto.de/ Yagarto-Tools http://yagarto.de/]
* [http://www.oracle.com/technetwork/java/javase/downloads/index.html Java JDK] Installation um Eclipse starten zu können.
* [http://eclipse.org/downloads/ Eclipse], der Download "Eclipse IDE for C/C++ Developers"
* [http://www.freddiechopin.info/ OpenOCD http://www.freddiechopin.info/] >> Download >> Software >> OpenOCD

''' Eclipse Demo-Projekt: '''

[[Media: Proj_Demo.zip | Blink-LED, komplettes Eclipse-Workspace von MmVisual]]
* Eclipse Workspace
* Mit OpenOCD und Dateien für den Olimex ARM-USB-OCD
* FW-Lib 3.4.0 von ST
* Start-Up Code als C-Datei, keine einzige Assembler-Datei
* Für STM32F103RB (128K Flash) wegen Initialisierung Stack-Pointer
* Nutzt make Tool, muss aber zu gmake umbenannt werden, ist weiter unten beschrieben

== Installation ==
=== Installation von Eclipse ===
Damit Eclipse gestartet werden kann, ist es nötig, dass zunächst Java installiert wird. Dabei muss einfach den Anweisungen des Installers gefolgt werden. Nachdem diese Installation abgeschlossen wurde, kann mit der Eclipse "Installation" fortgefahren werden.

Eclipse befindet sich (sofern im Download ausgewählt) in einem ZIP-Archiv. In diesem Archiv sind alle benötigten Dateien vorhanden, um Eclipse direkt starten zu können. Dieses ZIP-Archiv sollte dann zu C:\eclipse\ entpackt werden. In diesem Beispiel wird davon ausgegangen, dass eclipse zu den o.g. Pfad entpackt wird.

Sobald Eclipse vollständig entpackt wurde, kann eclipse gestartet werden. Während Eclipse startet, muss ein sog. Workspace ausgewählt werden. In diesem Workspace werden später alle Projekte und Sourcecodes abgelegt. Die Nachfolgende Grafik zeigt dieses Dialog-Fenster.
[[Datei:choose_workspace.png]]
Nachdem Eclipse erfolgreich gestartet werden kann, ist die Installation natürlich nicht abgeschlossen, da noch ein Compiler usw. für dem ARM-Mikrocontroller fehlt.

Für die Toolchain, sprich Compiler, newlib usw. hat man nun die Qual der Wahl, entweder man nimmt Yagarto-Tools oder Codesourcery. Der Unterschied zwischen den beiden toolchains ist nicht direkt erkennbar und soll an dieser Stelle nicht weiter behandelt werden. Ich verweise an dieser Stelle an den folgenden Foreneintrag:
[[http://www.mikrocontroller.net/topic/158503#1503836 Unterschied WinARM und Codesourcery]]

Ich persönlich habe mich für Codesourcery entschieden, da Truestuido von Atollic ebenfalls den none-eabi Compiler verwendet und dadurch die Linkerscripts direkt von Truestudio übernommen werden können.

=== Installation der Code-Sourcery Umgebung ===
Wer sich nun für die Code-Sourcery Umgebung entschieden hat, steht nun schon vor einem kleinerem Problem - Welche Version von Code-Sourcery soll man wählen?
Zur Auswahl stehen folgende Versionen:
* uCLinux
* EABI
* GNU/Linux
* SymbianOS
Hier ist die Wahl auf EABI beschränkt. Für weitere Hinweise siehe: [[http://www.codesourcery.com/sgpp/lite/arm/portal/doc9876/getting-started.pdf Codesourcery Getting-Started]]

Die Installation von Code-Sourcery ist komplett Menü geführt und entsprechend intuitiv durchzuführen. Dabei werden nachfolgend die wichtigsten Komponenten kurz erläutert:

CodeSourcery Common Startup Code Sequence
Diese vordefinierten Startup-Codes werden für den Start des Mikrocontrollers benutzt. Dabei wird der Stackpointer, die Interrupt-Handler usw. initialisiert. Die Benutzung dieser Startupcodes wird hier nicht näher Betrachtet, da STM vorgefertigte Startup-Codes kostenlos anbietet.

* CodeSourcery Debug Sprite for ARM
Die Debug-Sprite Umgebung ermöglicht das Debuggen eines Mikrocontrollers über JTAG. Debug-Sprite kann dabei über XML-Dateien konfiguriert werden. Jedoch kann Debug-Sprite nicht für das Debuggen von STM32-Mikrocontrollern verwendet werden.
GNU Binary Utilities (Binutils)
Die Binutils beinhaltet den GNU-Assembler sowie den für das Übersetzen eines C-Software-Modules benötigen Linker.

* GNU C Compiler (GCC)
Der GNU-C Compiler übersetzt den C-Code zu den sog. Object-Codes.

* GNU C++ Compiler (G++)
Der G++ Compiler übersetzt ein C++-Software-Modul zu Object-Codes, um damit die Verwendung von C++ auf einem Mikrocontroller zu ermöglichen.

* GNU C++ Runtime Library (Libstdc++)
Diese Library stellt C++ spezifische Funktionen zu Verfügung.

* GNU Debugger (GDB)
Der Debugger ist der GDB-Client, der für das Debuggen eines Software-Moduls genutzt wird.

* Newlib C Library

Die Newlib stellt die std-Lib für einen Mikrocontroller zu Verfügung. Dabei ist zu beachten, das die Newlib syscalls und stubs nutzt, um so eine Betriebssystemunabhängige Benutzung zu ermöglichen. Dies ermöglicht die Benutzung der Newlib auf einem Bare-Metal-System und auf einem uC-Linux basiertem Software-Modul.

Ich persönlich habe als Installationsverzeichnis C:\WinARM benutzt, damit die entsprechenden Pfade zu bestimmten binaris keine großartigen Sonderzeichen aufweisen.

=== Installation der Yagarto Umgebung ===
Die Installation sollte so ausgeführt werden, dass alles nach "C:\WinARM\" installiert wird, dazu müssen in den Setup-Paketen während des Setups immer die Pfade "C:\Programme\" angepasst werden. Damit kann man die gesamte Entwicklung und Konfiguration einfach sichern als ZIP Datei und sogar bei einem zweiten Rechner wieder einspielen.

Zu erst werden die Downloads von Yagarto geladen und installiert. Dort ist auch sehr gut beschrieben wie das Einrichten geht.
Allerdings fehlt auf der Yagarto-Seite der Hinweis auf den Download-Link des eigentlichen Eclipse Programms, daher ist er oben im Artikel aufgeführt.

Wenn man diese [http://yagarto.de/howto/yagarto2/index.html#download Yagarto-Anleitung] abgeschlossen hat kommt die Einrichtung von OpenOCD.
Eine Debugger-Einrichtung ist bei [http://yagarto.de/howto/yagarto2/index.html#cbug Yagarto] auch beschrieben, allerdings nicht für den STM32 Prozessor.

Nach der Installation von Yagarto-Tools muss eine Datei geändert werden:
C:\WinARM\yagarto-tools\bin\make.exe muss nach gmake.exe umbenannt werden.
Grund: Wenn man Delphi installiert hat, dann würde Eclipse das make Tool von Delphi finden und man kann das Eclipse Projekt nicht kompilieren.
Das Demo-Projekt nutzt auch das "gmake.exe".
Alternativ kann auch make.exe kopiert zu gmake.exe werden, wenn man kein Delphi installiert hat.

==== Start mit dem Demo-Projekt ====

Für alle Projekte habe ich das Verzeichnis C:\WinARM\Projekt\ vorgesehen, damit ist immer alles zusammen. Nun entpackt man das Demo-Projekt nach C:\WinARM\Projekt\ somit müsste dort ein neues Unterverzeichnis "Proj_Demo" vorhanden sein samt allen unterordnern.

Nun Eclipse Öffnen. Menü "File" >> "Switch Workspace" >> "Other...". In der Eingabezeile "Workspace:" wird nun das Verzeichnis "C:\WinARM\Projekt\Proj_Demo" eingegeben. Mit OK wird sich Eclipse beenden und neu starten.

Links im Baum sieht man das Projekt "BlinkLED":
* inc: die eigenen Includes
* lib: die FW-Lib von ST
* out: die kompilierten Dateien und listings
* prj: OpenOCD und LD Linker-Datei
* src: die eigenen Quellcodes
* makefile

Das Projekt wurde geschrieben für den STM32F103RC (256K Flash/48K RAM), läuft aber auch mit einem STM32F103xB da der Stack-Pointer auf 20K initialisiert wird. Details stehen in der Datei "src/stm32f10x_vector.c", Zeile 29,30:
<syntaxhighlight lang="c">#define STACK_TOP (0x20005000 - 4)
//#define STACK_TOP (0x2000C000 - 4)</syntaxhighlight>
Damit wird der Stack-Pointer für den RAM im Chip initialisiert.

Zum kompilieren rechten Mausklick auf das Projekt (normalerweise links im Navigator oder Projekt-Explorer) und dann im aufgehenden Kontextmenu auf "Build" klicken.
Mit Strg+B wird nicht nur das Projekt neu kompiliert sondern ALLE Projekte im aktuellen Workspace gerade offen sind. Wenn man dort nur ein Projekt hat geht auch CTRL-B.

''' Die Funktionen des Demo-Projekts '''
* Blink-LED auf Prot A.0, Port C.7, PortD.3,4,7,13 (STM3210C-EVAL Board)
* Initialisieren aller Variablen
* Initialisieren Clock auf HSI, 8MHz
* Initialisieren IO-Pins der LED's
* Initialisieren Timer für Systick
* Main-Schleife in der die Timer-Variablen gesetzt und die LED's ausgegeben werden
* Debug-Helper, siehe "src\DebugHelper.c"
* Systick-Interrupt
* komplett in C programmiert, kein Assembler
* ST FW-Lib V3.4.0 wird für alle Funktionen genutzt

'''Erster Start mit dem Demo-Projekt'''

Mit Eclipse mit der grünen Play-Taste mit dem roten Koffer "Run OpenOCD BlinkLED" "OpenOCD BlinkLED starten. Damit wird der GDB Server OpenOCD mit dem JTAG-Key ARM-USB-OCD gestartet. Wenn man einen anderen JTAG Adapter hat, so kann der mit dem kleinen schwarzen Pfeil im Menü "External Tools Configuration..." eingestellt werden. OpenOCD wird mit Start-Parametern gestartet, z.B. "-f .\prj\arm-usb-ocd.cfg" für das Olimex JTAG Interface. Wenn man nun ein anderes JTAG Interface hat, so muss hier der Dateiname geändert und in das Projekt nach "prj\" muss die CFG-Datei einkopiert werden.

Mit Eclipase mit der grünen Käfertaste (Debug BlinkLED), der kleine Pfeil nach unten, "BlinkLED OpenOCD Reset Load Run" ausführen. Damit wird der GDB Debugger gestartet, das Projekt geladen und gestartet. Der Debugger beendet sich dann automatisch und die CPU läuft.

=== Weitere Plug-Ins für Eclipse ===
Damit das Arbeiten mit Eclipse einfacher wird, gibt es zahlreiche Plug-Ins. Diese können mittels Eclipse heruntergeladen werden und werden dann automatisch installiert.

Die in meinen Augen wichtigsten Plug-Ins sind folgende:
* ARM-Plug-In
* Register View
* GDB-Plug-In

Das ARM-PlugIn stellt einen Wizzard bereit, in dem projektspezifische Einstellungen über den Compiler, Linkerscript usw. mit Hilfe einer GUI getroffen werden können.

Register View ermöglicht das Einsehen der General-Purpose Registern im Mikrocontroller. Dies kann beim Debuggen Hilfreich sein, da man anhand des Stack-Registers evtl. Stack-Overflows erkennen kann.

GDB-PlugIn mittels dem GDB-PlugIn ist es über Eclipse möglich, sich auf einen GDB-Server zu Connecten. Dabei kann dann aus Eclipse heraus direkt der Code-Debuggt werden.

== Einrichten eines eigenen Projektes ==

== Einrichtung GDB-Server ==

Ein GDB-Server wird immer unter "External Tools Configuration..." eingerichtet.

[[bild:MenuExternalTool.png]]

Mit Hilfe dieser Funktion kann ein beliebiges Programm gestartet werden.

=== OpenOCD mit ARM-USB-OCD von Olimex ===

Der Aufruf, mit Parameter HW-Interface und Prozessor:

[[bild:MenuExternalToolOOCD1.png]]

Der Eintrag im Eclipse-Menü:

[[bild:MenuExternalToolOOCD2.png]]

Die restlichen Reiter sind ohne Änderung.

=== JLink mit Segger GDB-Server einrichten ===

Im Demo-Projekt ist eine Konfiguration für den Segger GDB-Server enthalten. Dabei wird der GDB-Server so gestartet dass SWD als Kommunikation genutzt wird.

Der Aufruf, mit Parameter für SWD (Single Wire Debug):

[[bild:MenuExternalToolJLink.png]]

Der Pfad zum "JLinkGDBServer.exe" muss so angepasst werden je nach dem wohin er installiert wurde.

=== Einrichtung ST-Link (SWD Programmer vom Eval Board) ===
==== Einrichtung unter Windows ====
==== Einrichtung unter Linux ====

!!! Achtung !!! Das ST-Link projekt für Linux ist mit den neueren 3.0.X Kernel nicht mehr lauffähig und lässt den gesamten Rechner einfrieren !!!
Sollte sich dort etwas ändern, so werde ich dies hier bekannt geben.

Vielfach wurde genannt, daß es schade sei, daß das Discoveryboard oder das STLink nur unter Windows benutzen zu können. Mittlerweile hat sich dieses geändert, ohne das, dass STLink mit einer neuen Firmware beschrieben werden muss. Es gibt eine kleine Gruppe, die einen STLink GDB-Server für Linux realisiert haben. Mittlerweile befindet sich dieses Projekt noch in der Beta-Phase, jedoch konnten die ersten Tests überzeugen.

Dazu muss der Sourcecode von der Seite [[https://github.com/whitequark/stlink/blob/master/src/stlink-hw.c Projekt-Seite]] mittels git gecloned werden. (GIT Link: https://github.com/whitequark/stlink.git)
Damit ein Compilieren des Sourcecodes funktioniert, muss mittels apt-get oä. folgendes Paket installiert werden:
<pre>libsgutils2-dev</pre>
Nachdem dieses Paket installiert wurde, muss im Sourcecode noch einige Änderungen durchgeführt werden, da dort "unsauber" gecasted wurde.
Dieses Bezieht sich auf die Datei: "stlink-hw.c" und dort in den Zeilen:
1420, 1491, 1514.
Dort muss ein explizieter Cast zu (unsigned int) durchgeführt werden, so dass in der Zeile 1420 statt:
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + off);</syntaxhighlight>
nun
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + (unsigned int)off);</syntaxhighlight> steht. Diese Änderung ist bei den beiden verbleibenden Zeilen durchzuführen.
Nachdem dies abgeschlossen wurde müssen die Sourcecodes mittels dem Befehl:
<pre> make -C build </pre>
compiliert werden.
Der Start dieses GDB-Servers wird durch die Kommandozeile initiiert:
<pre>./build/st-util <<PORT>> /dev/sg<<SG-NUMBER>> </pre>
Mittels des Attributes <<PORT>> wird die Port-Nummer des GDB-Servers angegeben. Die ST-Link "Geräte Datei" wird (zumindest bei mir) nicht immer an dem gleichen Pfaden angegeben.

Nach dem Start sollte folgende Meldung (beim Discoverboard) erscheinen:
<pre>
*** stlink_open [/dev/sg4] ***
Chip ID is 10016420.
Device connected: Medium-density value line device
Device parameters: SRAM: 0x2000 bytes, Flash: up to 0x20000 bytes in pages of 0x400 bytes
Flash size is 128 KiB.
Listening at *:1234...
</pre>
Nun ist der GDB-Server aktiv und kann mittels Eclipse genutzt werden. Für die Einrichtung von Eclipse siehe: Einrichtung unter Windows.

== Tipps, Tricks und Stolpersteine ==

* Die Dateiendung einer C/H Datei muss kleingeschrieben sein, denn sonst meint der GCC Compiler dass es C++ Dateien sind.

* Wird VBox benutzt und einen Filter für den ST-Link bzw. des USB-Devices des Discovery-Boards eingerichtet, so kommt es zu schwerwiegenden Konflikten bei dem nächsten Start von VBox. Das Problem ist die Seriennummer vom ST-Link, welche nicht sichtbare Zeichen enthält. Ein Workaround zu diesem Problem: In dem eingerichtetem Filter muss die Seriennummer entfernt werden.

== MicroXplorer - MCU graphical configuration tool ==

Der [http://www.st.com/web/en/catalog/tools/PF251717 MicroXplorer von ST] ist ein Eclipse Plugin mit dem man sich die Peripheriefunktionen zusammen klicken kann die man beim STM32 Prozessor benötigt. Das Tool zeigt auch Kombinationen die nicht gehen. Somit kann man die Peripherie leichter planen.

Jedoch sollte man bei diesem Tool aufpassen: Wenn man z.B. zu erst CAN1 heraussucht und später FS_USB, so ist FS_USB nicht möglich. Wenn man das anders herum macht, so wird CAN1 auf alternative Pins gelegt und die Zuordnung klappt. Dennoch hilft es die Peripherie einfacher planen zu können.

== Weblinks, Foren, Communities ==
* Artikel [[STM32]]
* Artikel [[STM32 CooCox Installation]]
* [http://www.mikrocontroller.net/topic/214719 Thread zu diesem Thema]

[[Kategorie:STM32| ]]

STM32 Eclipse Installation

2014-01-24T08:04:19Z

Kichi: /* Installation von Eclipse unter Windows */

Dieser Artikel beschreibt, wie man Eclipse unter Windows installiert und für den Prozessor STM32 einrichtet, so dass ein Debuggen möglich ist.

== Installation von Eclipse unter Windows ==

'''Die Zusammenhänge:'''
* Eclipse - der Editor, ist eigentlich nichts weiteres als ein Editor, mit sehr viel Intelligenz
* Toolchain (make, Compiler, Linker, GDB, Bibliotheken, etc.). Hier gibt es verschiedene Möglichkeiten:
** YAGARTO GNU ARM toolchain - der Compiler und Debugger für Cortex-M3. Zusätzlich werden die Yagarto-Tools (make und sonstige Programme) benötigt.
** CodeSourcery beinhaltet alle benötigten Tools, wie make, GCC, GDB, Newlib usw.
** GNU Tools for ARM Embedded Processors benötigt zusätzlich ebenfalls make und rm bspw. aus den Yagarto-Tools
* CDT - Plugin, das Eclipse erweitert, sodaß C/C++ Programme editiert, kompiliert und gelinkt werden können. CDT steht für "C/C++ Development Tooling". Man kann Eclipse auch mit schon integrierten CDT auf der Eclipse Homepage bekommen.
* GDB Hardware Debugging - ein weiteres Eclipse-Plugin, welches notwendig ist, um mittels GDB und weiteren Tools Programme zu debuggen.
* GDB - der GNU Debugger, mit ihm ist es möglich, entsprechend kompilierte Programme auf C-Sourcelevel (und auch Assembler) zu debuggen. Er kann allerdings nicht direkt mit einem JTAG-Interface sprechen. Er "verbindet" sich dafür mit einem GDB-Server, der dann das JTAG-I/F anspricht.
* GDB-Server stellt Verbindung mit GDB und dem JTAG-Interface her. Er führt die Kommandos des GDBs aus. Der Server muss vor dem debuggen gestartet werden, da GDB einen laufenden GDB-Server erwartet. Die Verbindung zwischen dem GDB und dem GDB-Server wird über eine TCP/IP Verbindung hergestellt.
** OpenOCD - ein freier GDB-Server
** Texane STlink - ebenfalls frei
* JTAG-Interface, z.B. Olimex ARM-USB-OCD, ST-Link oder diverse andere. Meist über USB an den PC angeschlossen, über ein JTAG-Kabel wird der Adapter mit der Prozessor-Platine verbunden. Der GDB-Server nimmt Kommandos vom GDB entgegen und führt diese über das JTAG-I/F des Prozessors aus.
* STM32-Prozessor, ja den braucht es auch noch, sonst gibt es nichts zu debuggen.

Es sieht zwar auf den ersten Blick etwas komplex aus, aber es ist dennoch logisch aufgebaut.

== Downloads ==

Die benötigten Dateien für Eclipse:

* [http://yagarto.de/ Yagarto-Tools http://yagarto.de/]
* [http://www.oracle.com/technetwork/java/javase/downloads/index.html Java JDK] Installation um Eclipse starten zu können.
* [http://eclipse.org/downloads/ Eclipse], der Download "Eclipse IDE for C/C++ Developers"
* [http://www.freddiechopin.info/ OpenOCD http://www.freddiechopin.info/] >> Download >> Software >> OpenOCD

''' Eclipse Demo-Projekt: '''

[[Media: Proj_Demo.zip | Blink-LED, komplettes Eclipse-Workspace von MmVisual]]
* Eclipse Workspace
* Mit OpenOCD und Dateien für den Olimex ARM-USB-OCD
* FW-Lib 3.4.0 von ST
* Start-Up Code als C-Datei, keine einzige Assembler-Datei
* Für STM32F103RB (128K Flash) wegen Initialisierung Stack-Pointer
* Nutzt make Tool, muss aber zu gmake umbenannt werden, ist weiter unten beschrieben

== Installation ==
=== Installation von Eclipse ===
Damit Eclipse gestartet werden kann, ist es nötig, dass zunächst Java installiert wird. Dabei muss einfach den Anweisungen des Installers gefolgt werden. Nachdem diese Installation abgeschlossen wurde, kann mit der Eclipse "Installation" fortgefahren werden.

Eclipse befindet sich (sofern im Download ausgewählt) in einem ZIP-Archiv. In diesem Archiv sind alle benötigten Dateien vorhanden, um Eclipse direkt starten zu können. Dieses ZIP-Archiv sollte dann zu C:\eclipse\ entpackt werden. In diesem Beispiel wird davon ausgegangen, dass eclipse zu den o.g. Pfad entpackt wird.

Sobald Eclipse vollständig entpackt wurde, kann eclipse gestartet werden. Während Eclipse startet, muss ein sog. Workspace ausgewählt werden. In diesem Workspace werden später alle Projekte und Sourcecodes abgelegt. Die Nachfolgende Grafik zeigt dieses Dialog-Fenster.
[[Datei:choose_workspace.png]]
Nachdem Eclipse erfolgreich gestartet werden kann, ist die Installation natürlich nicht abgeschlossen, da noch ein Compiler usw. für dem ARM-Mikrocontroller fehlt.

Für die Toolchain, sprich Compiler, newlib usw. hat man nun die Qual der Wahl, entweder man nimmt Yagarto-Tools oder Codesourcery. Der Unterschied zwischen den beiden toolchains ist nicht direkt erkennbar und soll an dieser Stelle nicht weiter behandelt werden. Ich verweise an dieser Stelle an den folgenden Foreneintrag:
[[http://www.mikrocontroller.net/topic/158503#1503836 Unterschied WinARM und Codesourcery]]

Ich persönlich habe mich für Codesourcery entschieden, da Truestuido von Atollic ebenfalls den none-eabi Compiler verwendet und dadurch die Linkerscripts direkt von Truestudio übernommen werden können.

=== Installation der Code-Sourcery Umgebung ===
Wer sich nun für die Code-Sourcery Umgebung entschieden hat, steht nun schon vor einem kleinerem Problem - Welche Version von Code-Sourcery soll man wählen?
Zur Auswahl stehen folgende Versionen:
* uCLinux
* EABI
* GNU/Linux
* SymbianOS
Hier ist die Wahl auf EABI beschränkt. Für weitere Hinweise siehe: [[http://www.codesourcery.com/sgpp/lite/arm/portal/doc9876/getting-started.pdf Codesourcery Getting-Started]]

Die Installation von Code-Sourcery ist komplett Menü geführt und entsprechend intuitiv durchzuführen. Dabei werden nachfolgend die wichtigsten Komponenten kurz erläutert:

CodeSourcery Common Startup Code Sequence
Diese vordefinierten Startup-Codes werden für den Start des Mikrocontrollers benutzt. Dabei wird der Stackpointer, die Interrupt-Handler usw. initialisiert. Die Benutzung dieser Startupcodes wird hier nicht näher Betrachtet, da STM vorgefertigte Startup-Codes kostenlos anbietet.

* CodeSourcery Debug Sprite for ARM
Die Debug-Sprite Umgebung ermöglicht das Debuggen eines Mikrocontrollers über JTAG. Debug-Sprite kann dabei über XML-Dateien konfiguriert werden. Jedoch kann Debug-Sprite nicht für das Debuggen von STM32-Mikrocontrollern verwendet werden.
GNU Binary Utilities (Binutils)
Die Binutils beinhaltet den GNU-Assembler sowie den für das Übersetzen eines C-Software-Modules benötigen Linker.

* GNU C Compiler (GCC)
Der GNU-C Compiler übersetzt den C-Code zu den sog. Object-Codes.

* GNU C++ Compiler (G++)
Der G++ Compiler übersetzt ein C++-Software-Modul zu Object-Codes, um damit die Verwendung von C++ auf einem Mikrocontroller zu ermöglichen.

* GNU C++ Runtime Library (Libstdc++)
Diese Library stellt C++ spezifische Funktionen zu Verfügung.

* GNU Debugger (GDB)
Der Debugger ist der GDB-Client, der für das Debuggen eines Software-Moduls genutzt wird.

* Newlib C Library

Die Newlib stellt die std-Lib für einen Mikrocontroller zu Verfügung. Dabei ist zu beachten, das die Newlib syscalls und stubs nutzt, um so eine Betriebssystemunabhängige Benutzung zu ermöglichen. Dies ermöglicht die Benutzung der Newlib auf einem Bare-Metal-System und auf einem uC-Linux basiertem Software-Modul.

Ich persönlich habe als Installationsverzeichnis C:\WinARM benutzt, damit die entsprechenden Pfade zu bestimmten binaris keine großartigen Sonderzeichen aufweisen.

=== Installation der Yagarto Umgebung ===
Die Installation sollte so ausgeführt werden, dass alles nach "C:\WinARM\" installiert wird, dazu müssen in den Setup-Paketen während des Setups immer die Pfade "C:\Programme\" angepasst werden. Damit kann man die gesamte Entwicklung und Konfiguration einfach sichern als ZIP Datei und sogar bei einem zweiten Rechner wieder einspielen.

Zu erst werden die Downloads von Yagarto geladen und installiert. Dort ist auch sehr gut beschrieben wie das Einrichten geht.
Allerdings fehlt auf der Yagarto-Seite der Hinweis auf den Download-Link des eigentlichen Eclipse Programms, daher ist er oben im Artikel aufgeführt.

Wenn man diese [http://yagarto.de/howto/yagarto2/index.html#download Yagarto-Anleitung] abgeschlossen hat kommt die Einrichtung von OpenOCD.
Eine Debugger-Einrichtung ist bei [http://yagarto.de/howto/yagarto2/index.html#cbug Yagarto] auch beschrieben, allerdings nicht für den STM32 Prozessor.

Nach der Installation von Yagarto-Tools muss eine Datei geändert werden:
C:\WinARM\yagarto-tools\bin\make.exe muss nach gmake.exe umbenannt werden.
Grund: Wenn man Delphi installiert hat, dann würde Eclipse das make Tool von Delphi finden und man kann das Eclipse Projekt nicht kompilieren.
Das Demo-Projekt nutzt auch das "gmake.exe".
Alternativ kann auch make.exe kopiert zu gmake.exe werden, wenn man kein Delphi installiert hat.

==== Start mit dem Demo-Projekt ====

Für alle Projekte habe ich das Verzeichnis C:\WinARM\Projekt\ vorgesehen, damit ist immer alles zusammen. Nun entpackt man das Demo-Projekt nach C:\WinARM\Projekt\ somit müsste dort ein neues Unterverzeichnis "Proj_Demo" vorhanden sein samt allen unterordnern.

Nun Eclipse Öffnen. Menü "File" >> "Switch Workspace" >> "Other...". In der Eingabezeile "Workspace:" wird nun das Verzeichnis "C:\WinARM\Projekt\Proj_Demo" eingegeben. Mit OK wird sich Eclipse beenden und neu starten.

Links im Baum sieht man das Projekt "BlinkLED":
* inc: die eigenen Includes
* lib: die FW-Lib von ST
* out: die kompilierten Dateien und listings
* prj: OpenOCD und LD Linker-Datei
* src: die eigenen Quellcodes
* makefile

Das Projekt wurde geschrieben für den STM32F103RC (256K Flash/48K RAM), läuft aber auch mit einem STM32F103xB da der Stack-Pointer auf 20K initialisiert wird. Details stehen in der Datei "src/stm32f10x_vector.c", Zeile 29,30:
<syntaxhighlight lang="c">#define STACK_TOP (0x20005000 - 4)
//#define STACK_TOP (0x2000C000 - 4)</syntaxhighlight>
Damit wird der Stack-Pointer für den RAM im Chip initialisiert.

Zum kompilieren rechten Mausklick auf das Projekt (normalerweise links im Navigator oder Projekt-Explorer) und dann im aufgehenden Kontextmenu auf "Build" klicken.
Mit Strg+B wird nicht nur das Projekt neu kompiliert sondern ALLE Projekte im aktuellen Workspace gerade offen sind. Wenn man dort nur ein Projekt hat geht auch CTRL-B.

''' Die Funktionen des Demo-Projekts '''
* Blink-LED auf Prot A.0, Port C.7, PortD.3,4,7,13 (STM3210C-EVAL Board)
* Initialisieren aller Variablen
* Initialisieren Clock auf HSI, 8MHz
* Initialisieren IO-Pins der LED's
* Initialisieren Timer für Systick
* Main-Schleife in der die Timer-Variablen gesetzt und die LED's ausgegeben werden
* Debug-Helper, siehe "src\DebugHelper.c"
* Systick-Interrupt
* komplett in C programmiert, kein Assembler
* ST FW-Lib V3.4.0 wird für alle Funktionen genutzt

'''Erster Start mit dem Demo-Projekt'''

Mit Eclipse mit der grünen Play-Taste mit dem roten Koffer "Run OpenOCD BlinkLED" "OpenOCD BlinkLED starten. Damit wird der GDB Server OpenOCD mit dem JTAG-Key ARM-USB-OCD gestartet. Wenn man einen anderen JTAG Adapter hat, so kann der mit dem kleinen schwarzen Pfeil im Menü "External Tools Configuration..." eingestellt werden. OpenOCD wird mit Start-Parametern gestartet, z.B. "-f .\prj\arm-usb-ocd.cfg" für das Olimex JTAG Interface. Wenn man nun ein anderes JTAG Interface hat, so muss hier der Dateiname geändert und in das Projekt nach "prj\" muss die CFG-Datei einkopiert werden.

Mit Eclipase mit der grünen Käfertaste (Debug BlinkLED), der kleine Pfeil nach unten, "BlinkLED OpenOCD Reset Load Run" ausführen. Damit wird der GDB Debugger gestartet, das Projekt geladen und gestartet. Der Debugger beendet sich dann automatisch und die CPU läuft.

=== Weitere Plug-Ins für Eclipse ===
Damit das Arbeiten mit Eclipse einfacher wird, gibt es zahlreiche Plug-Ins. Diese können mittels Eclipse heruntergeladen werden und werden dann automatisch installiert.

Die in meinen Augen wichtigsten Plug-Ins sind folgende:
* ARM-Plug-In
* Register View
* GDB-Plug-In

Das ARM-PlugIn stellt einen Wizzard bereit, in dem projektspezifische Einstellungen über den Compiler, Linkerscript usw. mit Hilfe einer GUI getroffen werden können.

Register View ermöglicht das Einsehen der General-Purpose Registern im Mikrocontroller. Dies kann beim Debuggen Hilfreich sein, da man anhand des Stack-Registers evtl. Stack-Overflows erkennen kann.

GDB-PlugIn mittels dem GDB-PlugIn ist es über Eclipse möglich, sich auf einen GDB-Server zu Connecten. Dabei kann dann aus Eclipse heraus direkt der Code-Debuggt werden.

== Einrichten eines eigenen Projektes ==

== Einrichtung GDB-Server ==

Ein GDB-Server wird immer unter "External Tools Configuration..." eingerichtet.

[[bild:MenuExternalTool.png]]

Mit Hilfe dieser Funktion kann ein beliebiges Programm gestartet werden.

=== OpenOCD mit ARM-USB-OCD von Olimex ===

Der Aufruf, mit Parameter HW-Interface und Prozessor:

[[bild:MenuExternalToolOOCD1.png]]

Der Eintrag im Eclipse-Menü:

[[bild:MenuExternalToolOOCD2.png]]

Die restlichen Reiter sind ohne Änderung.

=== JLink mit Segger GDB-Server einrichten ===

Im Demo-Projekt ist eine Konfiguration für den Segger GDB-Server enthalten. Dabei wird der GDB-Server so gestartet dass SWD als Kommunikation genutzt wird.

Der Aufruf, mit Parameter für SWD (Single Wire Debug):

[[bild:MenuExternalToolJLink.png]]

Der Pfad zum "JLinkGDBServer.exe" muss so angepasst werden je nach dem wohin er installiert wurde.

=== Einrichtung ST-Link (SWD Programmer vom Eval Board) ===
==== Einrichtung unter Windows ====
==== Einrichtung unter Linux ====

!!! Achtung !!! Das ST-Link projekt für Linux ist mit den neueren 3.0.X Kernel nicht mehr lauffähig und lässt den gesamten Rechner einfrieren !!!
Sollte sich dort etwas ändern, so werde ich dies hier bekannt geben.

Vielfach wurde genannt, daß es schade sei, daß das Discoveryboard oder das STLink nur unter Windows benutzen zu können. Mittlerweile hat sich dieses geändert, ohne das, dass STLink mit einer neuen Firmware beschrieben werden muss. Es gibt eine kleine Gruppe, die einen STLink GDB-Server für Linux realisiert haben. Mittlerweile befindet sich dieses Projekt noch in der Beta-Phase, jedoch konnten die ersten Tests überzeugen.

Dazu muss der Sourcecode von der Seite [[https://github.com/whitequark/stlink/blob/master/src/stlink-hw.c Projekt-Seite]] mittels git gecloned werden. (GIT Link: https://github.com/whitequark/stlink.git)
Damit ein Compilieren des Sourcecodes funktioniert, muss mittels apt-get oä. folgendes Paket installiert werden:
<pre>libsgutils2-dev</pre>
Nachdem dieses Paket installiert wurde, muss im Sourcecode noch einige Änderungen durchgeführt werden, da dort "unsauber" gecasted wurde.
Dieses Bezieht sich auf die Datei: "stlink-hw.c" und dort in den Zeilen:
1420, 1491, 1514.
Dort muss ein explizieter Cast zu (unsigned int) durchgeführt werden, so dass in der Zeile 1420 statt:
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + off);</syntaxhighlight>
nun
<syntaxhighlight lang="c">fprintf(stderr, "run_flash_loader(0x%x) == -1\n", addr + (unsigned int)off);</syntaxhighlight> steht. Diese Änderung ist bei den beiden verbleibenden Zeilen durchzuführen.
Nachdem dies abgeschlossen wurde müssen die Sourcecodes mittels dem Befehl:
<pre> make -C build </pre>
compiliert werden.
Der Start dieses GDB-Servers wird durch die Kommandozeile initiiert:
<pre>./build/st-util <<PORT>> /dev/sg<<SG-NUMBER>> </pre>
Mittels des Attributes <<PORT>> wird die Port-Nummer des GDB-Servers angegeben. Die ST-Link "Geräte Datei" wird (zumindest bei mir) nicht immer an dem gleichen Pfaden angegeben.

Nach dem Start sollte folgende Meldung (beim Discoverboard) erscheinen:
<pre>
*** stlink_open [/dev/sg4] ***
Chip ID is 10016420.
Device connected: Medium-density value line device
Device parameters: SRAM: 0x2000 bytes, Flash: up to 0x20000 bytes in pages of 0x400 bytes
Flash size is 128 KiB.
Listening at *:1234...
</pre>
Nun ist der GDB-Server aktiv und kann mittels Eclipse genutzt werden. Für die Einrichtung von Eclipse siehe: Einrichtung unter Windows.

== Tipps, Tricks und Stolpersteine ==

* Die Dateiendung einer C/H Datei muss kleingeschrieben sein, denn sonst meint der GCC Compiler dass es C++ Dateien sind.

* Wird VBox benutzt und einen Filter für den ST-Link bzw. des USB-Devices des Discovery-Boards eingerichtet, so kommt es zu schwerwiegenden Konflikten bei dem nächsten Start von VBox. Das Problem ist die Seriennummer vom ST-Link, welche nicht sichtbare Zeichen enthält. Ein Workaround zu diesem Problem: In dem eingerichtetem Filter muss die Seriennummer entfernt werden.

== MicroXplorer - MCU graphical configuration tool ==

Der [http://www.st.com/web/en/catalog/tools/PF251717 MicroXplorer von ST] ist ein Eclipse Plugin mit dem man sich die Peripheriefunktionen zusammen klicken kann die man beim STM32 Prozessor benötigt. Das Tool zeigt auch Kombinationen die nicht gehen. Somit kann man die Peripherie leichter planen.

Jedoch sollte man bei diesem Tool aufpassen: Wenn man z.B. zu erst CAN1 heraussucht und später FS_USB, so ist FS_USB nicht möglich. Wenn man das anders herum macht, so wird CAN1 auf alternative Pins gelegt und die Zuordnung klappt. Dennoch hilft es die Peripherie einfacher planen zu können.

== Weblinks, Foren, Communities ==
* Artikel [[STM32]]
* Artikel [[STM32 CooCox Installation]]
* [http://www.mikrocontroller.net/topic/214719 Thread zu diesem Thema]

[[Kategorie:STM32| ]]

USB HID Host Treiber

2011-04-22T08:05:50Z

Kichi:

USB HID Schnittstellen für Steuerungsaufgaben zu verwenden ist allgemein üblich in der Elektronik. Es gibt unzählige Mikrocontroller mit USB von einer ganzen Menge Hersteller, welche die notwendige Firmware schon mitbringen. Aber auf PC Seite ist es immer noch mit einigem Aufwand verbunden, wenn man den USB nutzen will. Sparen Sie sich die Mühe und verwenden Sie die AHID Bibliothek.

===Funktionen===

* '''AHid_Init():''' initialisiert den Treiber.
* '''AHid_Register():''' registriert die Schnittstelle.
* '''AHid_Write():''' schreibt Daten.
* '''AHid_Read():''' ließt Daten ein.
* '''AHid_Request():''' fordert einen Feature Report an.
* '''AHid_Attached():''' stellt Anschluß an den USB fest.
* '''AHid_Find():''' sucht die Schnittstelle am Bus.
* '''AHid_Flush():''' löscht die Datenpuffer.
* '''AHid_Info():''' zeigt Treiber-Infos an.

===Konzept===

Die Bibliothek wird durch einmaligen Aufruf der Funktion AHid_Init() zu Beginn initialisiert. Mit AHid_Register() erhält man Zugriff auf das gewünschte USB-Gerät. Die Funktion öffnet eine Schnittstelle für den Datentransfer.

AHid_Write() dient zum Senden von Daten an das USB-Gerät. Hierbei wird ein Interrupt- oder Control-Transfer (Feature Report) verwendet (je nach Festlegung bei der Registrierung). Der Datenempfang erfolgt durch AHid_Read(). Bei Interrupt-Transfers wird hierfür ein eigener Thread gestartet, der fortlaufend die Schnittstelle auf ankommende Daten hin prüft. Sobald Daten vorliegen, wird an die Anwendung eine AHID_DATARECEIVED-Nachricht verschickt. Innerhalb der Nachrichtenschleife kann man dann auf diese Daten mit AHid_Read() zugreifen. Der Empfang von Feature Reports unterscheidet sich etwas von diesem Ablauf. Feature Reports müssen nämlich aktiv angefordert werden, was die Funktion AHid_Request() erledigt. Nach erfolgreichem Erhalt des Feature Reports wird wiederum eine AHID_DATARECEIVED-Nachricht verschickt und AHid_Read() erledigt dann den Rest. Durch dieses Konzept werden alle eingehenden Daten (unabhängig vom Transfertyp) an eine Stelle der Nachrichtenschleife transportiert. Das erleichtert das Erstellen einer Zustandsmaschine.

Die Funktion AHid_Attached() stellt fest, ob das USB-Gerät überhaupt am Bus verfügbar ist und gibt einen entsprechenden Wert zurück. AHid_Find() macht in etwa das Gleiche. Die Funktion sucht das USB-Gerät und gibt über den Rückgabewert den entsprechenden Zustand aus. Mit der Funktion AHid_Flush() werden die internen Datenpuffer gelöscht. Das kann notwendig sein, falls z.B. das USB-Gerät vom Bus abgeklemmt wird, und man noch nicht ausgelesene Daten sicher löschen möchte. AHid_Info() hat im normalen Betrieb keine Funktion. Es zeigt lediglich ein paar Informationen über die AHID Bibliothek an.

Die AHID Library ist eine '''Dynamic Link Library (DLL)''' und arbeitet mit verschiedenen Programmiersprachen zusammen.
Sie steht zusammen mit den folgenden '''Demo-Anwendungen''' als Download auf http://embedded24.net bereit:

* AHID Demo C++ (Visual Studio C++ 2010)
* AHID Demo C# (Visual Studio C# 2010)
* AHID Demo VB (Visual Studio VB 2010)

===Download===

http://www.embedded24.net

===Diskussion===

http://www.mikrocontroller.net/topic/210792

===Kontakt===

e24(at)basic.io

===Alternativen===
Zu obigem Treiber gibt es u.a. folgende Alternativen (hauptsächlich für C#), deren Sourcen frei zugänglich sind:
* GenericHID von Jan Axelson ([http://www.lvr.com/hidpage.htm#MyExampleCode Link])
* HidLibrary von Mike O'Brien ([https://github.com/mikeobrien/HidLibrary Link])
* HID USB Library von Florian Leitner ([http://www.florian-leitner.de/index.php/2007/08/03/hid-usb-driver-library/#download Link])
* Generic HID USB class-library vom Simon Inns ([http://www.waitingforfriday.com/index.php/Open_Source_Framework_for_USB_Generic_HID_devices_based_on_the_PIC18F_and_Windows#Files_for_download Link])
* USB HID Component von wimar ([http://www.codeproject.com/script/Articles/ViewDownloads.aspx?aid=18099 Link])
* USBwisec von Bryan Batchelder ([http://sourceforge.net/projects/usbwisec/develop Link])
[[Kategorie:USB]]

Datei:Programme miniLA with xc3sprog bat.zip

2009-06-10T23:18:45Z

Kichi: hat eine neue Version von „Bild:Programme miniLA with xc3sprog bat.zip“ hochgeladen

MiniLA

2009-06-10T23:17:28Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
==== Mainboard ====
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

==== Tastköpfe ====
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

==== Trigger ====
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

Hinweise:
* Der 74AC244N dient nur als Platzhalter. Hier soll stattdessen (wie bei den Tastköpfen auch) ein 74LVC244 bestückt werden.
* R6 bis R10 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R11 bis R15 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

==== Sonstiges ====
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen [http://www.mikrocontroller.net/topic/93848 Beitrag in der Codesammlung].

=== CPLD-Programmierung ===
Für die [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD]s gibt es zwei Möglichkeiten:

==== via LPT ====
Dazu wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden. Eine Beschreibung der Vorgehensweise findet sich auf der miniLA-Projektseite.

==== via USB ====
Dank eines [http://www.mikrocontroller.net/topic/60340#1261817 Beitrags von Uwe Bonnes] bin ich auf das Programm "[http://sourceforge.net/projects/xc3sprog xc3sprog]" gestossen, mit dem der CPLD mittels FT2232 programmiert werden kann. Da bei der miniLA-Version von Bob Grieb bereits ein FT2232 auf dem Board bestückt ist, wird keine weitere Hardware (außer ein paar Litzen) benötigt.

Vorgehensweise:
<ol>
<li>xc3sprog herunterladen</li>
<li>Inhalt des Ordners "build-win32" entpacken</li>
<li>Zu programmierende Firmware (*.jed) in diesen Ordner kopieren
<li>[http://libusb-win32.sourceforge.net libusb] installieren (sofern nicht schon geschehen)</li>
<li>FT2232 und CPLD folgendermaßen verbinden</li>
* K10.1 / ADBUS0 / USBD0 <-> E3 / E7 / TCK
* K10.2 / ADBUS1 / USBD1 <-> E2 / E6 / TDI
* K10.3 / ADBUS2 / USBD2 <-> E1 / E5 / TDO
* K10.4 / ADBUS3 / USBD3 <-> E4 / E8 / TMS
<li>FT2232 und den Rest der Schaltung einschalten (mit USB bzw. Betriebsspannung verbinden)</li>
<li>Eingabeaufforderung öffnen und in das Verzeichnis "build-win32" wechseln</li>
<li>"xc3sprog -c ftdi -v firmware.jed" (ohne "") eingeben und bestätigen, wobei firmware.jed für die Datei steht, die unter Punkt 3 kopiert wurde</li>
</ol>
Die obige Anweisung gilt für Windows unter Benutzung des FT2232 auf dem miniLA-Mainboard. Es gibt aber auch eine Linux-Version von xc3sprog und es kann eine andere Platine mit FT2232 genutzt werden.

Ich habe mir zwecks einfacherer Handhabung ein kleines [[Media:Programme_miniLA_with_xc3sprog_bat.zip‎|Batch-Script]] zum Programmieren geschrieben. Zusätzlich zu den enthaltenen Dateien, muss der Inhalt des Ordners "build-win32" und die *.jed-Files in das Verzeichnis kopiert und entsprechend benannt werden ("miniLA_state2.2.jed", "miniLA_time1.7_20mhz.jed", "miniLA_time1.7_40mhz.jed", "miniLA_time1.7_80mhz.jed" und "miniLA_time1.7_100mhz.jed"). Anschließend "programme_miniLA.bat" aufrufen und den Anweisungen folgen.

== Siehe auch ==
Nachfolgend eine Zusammenfassung relevanter bzw. interessanter Links und Daten:
* [http://minila.sourceforge.net miniLA Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://sourceforge.net/projects/xc3sprog xc3sprog Projekt-Seite]
* [http://libusb.wiki.sourceforge.net libusb für Linux]
* [http://libusb-win32.sourceforge.net libusb für Windows]
Diskussionen und Artikel auf www.mikrocontroller.net:
* Artikel: [[Logic Analyzer]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]

== ToDo ==

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-06-10T23:12:08Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
==== Mainboard ====
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

==== Tastköpfe ====
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

==== Trigger ====
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

Hinweise:
* Der 74AC244N dient nur als Platzhalter. Hier soll stattdessen (wie bei den Tastköpfen auch) ein 74LVC244 bestückt werden.
* R6 bis R10 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R11 bis R15 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

==== Sonstiges ====
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen [http://www.mikrocontroller.net/topic/93848 Beitrag in der Codesammlung].

=== CPLD-Programmierung ===
Für die [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD]s gibt es zwei Möglichkeiten:

==== via LPT ====
Dazu wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden. Eine Beschreibung der Vorgehensweise findet sich auf der miniLA-Projektseite.

==== via USB ====
Dank eines [http://www.mikrocontroller.net/topic/60340#1261817 Beitrags von Uwe Bonnes] bin ich auf das Programm "[http://sourceforge.net/projects/xc3sprog xc3sprog]" gestossen, mit dem der CPLD mittels FT2232 programmiert werden kann. Da bei der miniLA-Version von Bob Grieb bereits ein FT2232 auf dem Board bestückt ist, wird keine weitere Hardware (außer ein paar Litzen) benötigt.

Vorgehensweise:
<ol>
<li>xc3sprog herunterladen</li>
<li>Inhalt des Ordners "build-win32" entpacken</li>
<li>Zu programmierende Firmware (*.jed) in diesen Ordner kopieren
<li>[http://libusb-win32.sourceforge.net libusb] installieren (sofern nicht schon geschehen)</li>
<li>FT2232 und CPLD folgendermaßen verbinden</li>
* K10.1 / ADBUS0 / USBD0 <-> E3 / E7 / TCK
* K10.2 / ADBUS1 / USBD1 <-> E2 / E6 / TDI
* K10.3 / ADBUS2 / USBD2 <-> E1 / E5 / TDO
* K10.4 / ADBUS3 / USBD3 <-> E4 / E8 / TMS
<li>FT2232 und den Rest der Schaltung einschalten (mit USB bzw. Betriebsspannung verbinden)</li>
<li>Eingabeaufforderung öffnen und in das Verzeichnis "build-win32" wechseln</li>
<li>"xc3sprog -c ftdi -v firmware.jed" (ohne "") eingeben und bestätigen, wobei firmware.jed für die Datei steht, die unter Punkt 3 kopiert wurde</li>
</ol>
Die obige Anweisung gilt für Windows unter Benutzung des FT2232 auf dem miniLA-Mainboard. Es gibt aber auch eine Linux-Version von xc3sprog und es kann eine andere Platine mit FT2232 genutzt werden.

Ich habe mir zwecks einfacherer Handhabung ein kleines [[Media:Programme_miniLA_with_xc3sprog_bat.zip‎|Batch-Script]] zum Programmieren geschrieben. Zusätzlich zu den beiden enthaltenen Dateien, muss der Inhalt des Ordners "build-win32" und die *.jed-Files in das Verzeichnis kopiert und entsprechend benannt werden ("miniLA_state2.2.jed", "miniLA_time1.7_20mhz.jed", "miniLA_time1.7_40mhz.jed", "miniLA_time1.7_80mhz.jed" und "miniLA_time1.7_100mhz.jed"). Anschließend "programme_miniLA.bat" aufrufen und den Anweisungen folgen.

== Siehe auch ==
Nachfolgend eine Zusammenfassung relevanter bzw. interessanter Links und Daten:
* [http://minila.sourceforge.net miniLA Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://sourceforge.net/projects/xc3sprog xc3sprog Projekt-Seite]
* [http://libusb.wiki.sourceforge.net libusb für Linux]
* [http://libusb-win32.sourceforge.net libusb für Windows]
Diskussionen und Artikel auf www.mikrocontroller.net:
* Artikel: [[Logic Analyzer]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]

== ToDo ==

[[Category:Projekte]] [[Category:FPGA und Co]]

Datei:Programme miniLA with xc3sprog bat.zip

2009-06-10T23:04:31Z

Kichi:

MiniLA

2009-06-10T22:57:01Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
==== Mainboard ====
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

==== Tastköpfe ====
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

==== Trigger ====
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

Hinweise:
* Der 74AC244N dient nur als Platzhalter. Hier soll stattdessen (wie bei den Tastköpfen auch) ein 74LVC244 bestückt werden.
* R6 bis R10 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R11 bis R15 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

==== Sonstiges ====
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen [http://www.mikrocontroller.net/topic/93848 Beitrag in der Codesammlung].

=== CPLD-Programmierung ===
Für die [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD]s gibt es zwei Möglichkeiten:

==== via LPT ====
Dazu wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden. Eine Beschreibung der Vorgehensweise findet sich auf der miniLA-Projektseite.

==== via USB ====
Dank eines [http://www.mikrocontroller.net/topic/60340#1261817 Beitrags von Uwe Bonnes] bin ich auf das Programm "[http://sourceforge.net/projects/xc3sprog xc3sprog]" gestossen, mit dem der CPLD mittels FT2232 programmiert werden kann. Da bei der miniLA-Version von Bob Grieb bereits ein FT2232 auf dem Board bestückt ist, wird keine weitere Hardware (außer ein paar Litzen) benötigt.

Vorgehensweise:
<ol>
<li>xc3sprog herunterladen</li>
<li>Inhalt des Ordners "build-win32" entpacken</li>
<li>Zu programmierende Firmware (*.jed) in diesen Ordner kopieren
<li>[http://libusb-win32.sourceforge.net libusb] installieren (sofern nicht schon geschehen)</li>
<li>FT2232 und CPLD folgendermaßen verbinden</li>
* K10.1 / ADBUS0 / USBD0 <-> E3 / E7 / TCK
* K10.2 / ADBUS1 / USBD1 <-> E2 / E6 / TDI
* K10.3 / ADBUS2 / USBD2 <-> E1 / E5 / TDO
* K10.4 / ADBUS3 / USBD3 <-> E4 / E8 / TMS
<li>FT2232 und den Rest der Schaltung einschalten (mit USB bzw. Betriebsspannung verbinden)</li>
<li>Eingabeaufforderung öffnen und in das Verzeichnis "build-win32" wechseln</li>
<li>"xc3sprog -c ftdi -v firmware.jed" (ohne "") eingeben und bestätigen, wobei firmware.jed für die Datei steht, die unter Punkt 3 kopiert wurde</li>
</ol>
Die obige Anweisung gilt für Windows unter Benutzung des FT2232 auf dem miniLA-Mainboard. Es gibt aber auch eine Linux-Version von xc3sprog und es kann eine andere Platine mit FT2232 genutzt werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung relevanter bzw. interessanter Links und Daten:
* [http://minila.sourceforge.net miniLA Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://sourceforge.net/projects/xc3sprog xc3sprog Projekt-Seite]
* [http://libusb.wiki.sourceforge.net libusb für Linux]
* [http://libusb-win32.sourceforge.net libusb für Windows]
Diskussionen und Artikel auf www.mikrocontroller.net:
* Artikel: [[Logic Analyzer]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]

== ToDo ==

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-05-08T21:48:14Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

=== Tastköpfe ===
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

=== Trigger ===
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

Hinweise:
* Der 74AC244N dient nur als Platzhalter. Hier soll stattdessen (wie bei den Tastköpfen auch) ein 74LVC244 bestückt werden.
* R6 bis R10 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R11 bis R15 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

=== Sonstiges ===
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag [http://www.mikrocontroller.net/topic/93848 in der Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* [http://minila.sourceforge.net Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [[Logic Analyzer]]

== ToDo ==
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-05-06T20:34:12Z

Kichi: /* Trigger */

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

=== Tastköpfe ===
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

=== Trigger ===
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

Hinweise:
* Der 74AC244N dient nur als Platzhalter. Hier soll stattdessen (wie bei den Tastköpfen auch) ein 74LVC244 bestückt werden.

=== Sonstiges ===
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag [http://www.mikrocontroller.net/topic/93848 in der Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* [http://minila.sourceforge.net Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [[Logic Analyzer]]

== ToDo ==
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-05-06T20:33:39Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

=== Tastköpfe ===
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

=== Trigger ===
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

Hinweise:
* Der 74AC244N dient nur als Platzhalter. Hier soll (wie bei den Tastköpfen auch) ein 74LVC244 bestückt werden.

=== Sonstiges ===
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag [http://www.mikrocontroller.net/topic/93848 in der Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* [http://minila.sourceforge.net Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [[Logic Analyzer]]

== ToDo ==
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-05-05T19:58:24Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right|miniLA Bestückseite]]
[[Image:Minila_best_bot.jpg|thumb|300px|right|miniLA Lötseite]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum bereits drei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die zweite im Herbst 2008 und die dritte im Frühling 2009 statt. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Die Daten zu dieser überarbeiteten Version sind [[Media:Minila%26usb-v1.zip|hier]] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [[Media:Minila-parts.zip|Link-Liste]] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

[[Image:Ram_bigger_than_128k.jpg|thumb|150px|right|Brücke bei Verwendung von K7B803625B-PI65 (siehe Text)]]
Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

Falls ein SRAM verwendet wird, das größer ist als 128k, müssen evtl. ein paar Brücken eingelötet werden. Dies hängt von der Pinbelegung des SRAMs ab - meistens müssen nur Adressleitungen beschaltet werden, die sonst in der Luft hängen würden. Beim K7B803625B-PI65 aus den Sammelbestellungen wäre das bei Pin 43 (= A17) der Fall. Im nebenstehenden Bild ist Pin 43 mit GND verbunden. Es wäre aber ebenfalls möglich den Pin mit einem anderen Adresspin zu verbinden (z.B. Pin 44) oder mit Vcc, je nachdem was am einfachsten ist.

=== Tastköpfe ===
[[Image:Probe_best_top.JPG|thumb|150px|right|Tastkopf Bestückseite (inkl. Flachbandkabel zum miniLA)]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [[Media:Probe_244dil.zip|hier]].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

=== Trigger ===
Die obigen Platinen passen leider nur für die 32 Kanäle (K2-K5), nicht jedoch für die Trigger-Ein- und Clock-Ausgänge. Deswegen wurde im Zuge der dritten Sammelbestellung zusätzlich zu den Tastköpfen noch eine Triggerplatine entwickelt. Um Verwechslungen mit den Tastköpfen zu vermeiden ist auf dieser Platine eine 10polige Kontaktierung vorgesehen, die mit K1 des miniLA verbunden wird. Pin 7 (X8) davon ist im Moment noch nicht belegt und kann für eventuelle spätere Erweiterungen verwendet werden. Die beiden Jumper auf der Unterseite sind vorgesehen um die Richtung (Ein-/Ausgang) entsprechend wählen zu können. Schaltplan, Stückliste und Bestückpläne sind [[Media:MiniLA-Trigger.zip|hier]] zu finden.

=== Sonstiges ===
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag [http://www.mikrocontroller.net/topic/93848 in der Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [[Media:Xilinx_programmer.zip|hier]] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* [http://minila.sourceforge.net Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [[Media:Minila%26usb-v1.zip|Überarbeitete Version davon (inkl. Stückliste)]]
* [[Media:Xilinx_programmer.zip|Eagle-Projekt für martiniman's Programmer]]
* [[Media:Probe_244dil.zip|Daten der Tastköpfe (inkl. Stückliste)]]
* [[Media:MiniLA-Trigger.zip|Daten der Triggerplatinen (inkl. Stückliste)]]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [[Logic Analyzer]]

== ToDo ==
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

Datei:MiniLA-Trigger.zip

2009-05-05T19:57:08Z

Kichi: hat eine neue Version von „Bild:MiniLA-Trigger.zip“ hochgeladen

Datei:MiniLA-Trigger.zip

2009-05-05T19:53:00Z

Kichi:

MiniLA

2009-04-24T19:26:27Z

Kichi:

MiniLA

2009-04-24T19:20:49Z

Kichi:

Datei:Ram bigger than 128k.jpg

2009-04-24T19:12:53Z

Kichi:

MiniLA

2009-03-08T12:37:52Z

Kichi:

MiniLA

2009-03-08T10:25:45Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right]]
[[Image:Minila_best_bot.jpg|thumb|300px|right]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum zwei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die andere im Herbst 2008 statt. Zur Zeit (19.02.09) ist eine dritte Sammelbestellung in Vorbereitung. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Diese überarbeitete Version ist [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip hier] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT (ohne USB): [http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084 Reichelt-Warenkorb]
* Hühnerfutter inkl. LPT & USB: [http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084 Reichelt-Warenkorb]
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: [http://www.mikrocontroller.net/wikifiles/5/58/Minila-parts.zip Link-Liste] oder Suche über http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe >= 128k
*Datenbreite >= 32bits
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

=== Tastköpfe ===
[[Image:Probe_best_top.JPG|thumb|150px|right]]
Als Schutz für den CPLD wurde eine Art Tastkopf entwickelt, der zwischen das zu messende Signal und den miniLA geschaltet wird. Dieser Tastkopf ist sehr einfach gehalten und besteht aus nur wenigen Bauteilen. Ein Tastkopf dient für 8 Kanäle, d.h. für alle 32 Kanäle werden 4 Stück benötigt. Die Schaltung wurde mittels TinyCAD und FreePCB entwickelt und die Daten dazu finden sich [http://www.mikrocontroller.net/wikifiles/3/34/Probe_244dil.zip hier].

Hinweise:
* R9 bis R16 dienen zur Terminierung und können überbrückt werden, da sich auf der Hauptplatine ebenfalls Serienwiderstände finden.
* R17 bis R24 dienen als Platzhalter falls eine Hysterese gewünscht sein sollte. Auf jeden Fall sollen hier keine 47Ohm-Widerstände bestückt werden, sondern welche im 10k- bis 100k-Bereich.

=== Sonstiges ===
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag [http://www.mikrocontroller.net/topic/93848 in der Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip hier] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* [http://minila.sourceforge.net Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip Überarbeitete Version davon (inkl. Stückliste)]
* [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip Eagle-Projekt für martiniman's Programmer]
* [http://www.mikrocontroller.net/wikifiles/3/34/Probe_244dil.zip Daten der Tastköpfe (inkl. Stückliste)]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [http://www.mikrocontroller.net/articles/Logic_Analyzer Logic Analyzer]

== ToDo ==
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

Datei:Minila-parts.zip

2009-03-08T10:17:56Z

Kichi: Linklist to miniLA-parts at Digikey

Linklist to miniLA-parts at Digikey

Datei:Probe best top.JPG

2009-03-08T10:12:41Z

Kichi:

Datei:Probe 244dil.zip

2009-03-08T09:50:05Z

Kichi: probe for miniLA

probe for miniLA

MiniLA

2009-02-19T16:38:59Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right]]
[[Image:Minila_best_bot.jpg|thumb|300px|right]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum zwei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die andere im Herbst 2008 statt. Zur Zeit (19.02.09) ist eine dritte Sammelbestellung in Vorbereitung. Details zu den Bestellungen und teils auch zur Hardware finden sich [http://www.mikrocontroller.net/topic/86889 in diesem Thread].

== Hardware ==
=== Allgemein ===
Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils rein optischer Natur sind. Diese überarbeitete Version ist [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip hier] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

=== Bauteile ===
Leider ist es nicht ganz einfach an einige der Bauteile zu kommen.

Bei den ersten beiden Sammelbestellungen wurden die Bauteile aus folgenden Quellen bezogen:
* Hühnerfutter für o.g. Version inkl. LPT: http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084
* Hühnerfutter inkl. LPT & USB: http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144), zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bzgl. SRAM wurde seinerzeit nach passenden Alternativen zum ursprünglich verwendeten Alliance AS7C33128PFS32A gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Folgende SRAMs wurden bereits erfolgreich eingesetzt:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe (>= 128k)
*Datenbreite (>= 32bits)
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

=== Sonstiges ===
Zum Betreiben des miniLA wird zusätzlich zu den, in der Stückliste aufgeführten Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag [http://www.mikrocontroller.net/topic/93848 in der Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip hier] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* [http://minila.sourceforge.net Projekt-Seite]
* [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb's Version (Basis der Sammelbestellungen)]
* [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip Überarbeitete Version davon (inkl. Stückliste)]
* [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip Eagle-Projekt für martiniman's Programmer]
* [http://www.mikrocontroller.net/topic/86889 Diskussion zu den Sammelbestellungen]
* [http://www.mikrocontroller.net/topic/93848 Diskussion zur PC-Software]
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [http://www.mikrocontroller.net/articles/Logic_Analyzer Logic Analyzer]

== ToDo ==
* Informationen zu den "Tastköpfen" fehlen
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-02-18T19:08:05Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right]]
[[Image:Minila_best_bot.jpg|thumb|300px|right]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum zwei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die andere im Herbst 2008 statt. Insgesamt sind dabei etwa 40 Teilesätze und 20 einzelne Platinen in Umlauf gelangt. Details zu den Bestellungen und teils auch zur Hardware finden sich im [http://www.mikrocontroller.net/topic/86889 Forum].

== Hardware ==
'''Allgemein'''

Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils nur optischer Natur sind. Diese überarbeitete Version ist [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip hier] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

'''Bauteile'''

Leider ist es nicht ganz einfach an die Bauteile zu kommen. Bei den Sammelbestellungen wurde das "Hühnerfutter" bei Reichelt, das SRAM bei EBV und die restlichen Teile bei Digikey bestellt.

Bzgl. SRAM wurde seinerzeit nach passenden Typen gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Bezugsquellen für die Teile:
* Hühnerfutter für o.g. Version inkl. LPT: http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084
* Hühnerfutter inkl. LPT & USB: http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144). Zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bereits erfolgreich eingesetzte SRAMs:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe (>= 128k)
*Datenbreite (>= 32bits)
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

'''Sonstiges'''

Zum Betreiben des miniLA wird zusätzlich zu den eigentlichen Bauteilen
* ein USB-Kabel (A- auf B-Stecker, wie bei Druckern) oder ein LPT-Kabel
* ein Netzteil (~5V / ~700mA)
benötigt.

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag in der [http://www.mikrocontroller.net/topic/93848 Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip hier] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* Projekt-Seite: http://minila.sourceforge.net
* Bob Grieb's Version (Basis der Sammelbestellungen): http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw
* Überarbeitete Version davon (inkl. Stückliste): http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip
* Eagle-Projekt für martiniman's Programmer: http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip
* Diskussion zur Sammelbestellung: http://www.mikrocontroller.net/topic/86889
* Diskussion zur PC-Software: http://www.mikrocontroller.net/topic/93848
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [http://www.mikrocontroller.net/articles/Logic_Analyzer Logic Analyzer]

== ToDo ==
* Informationen zu den "Tastköpfen" fehlen
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-02-16T22:15:21Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right]]
[[Image:Minila_best_bot.jpg|thumb|300px|right]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum zwei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die andere im Herbst 2008 statt. Insgesamt sind dabei etwa 40 Teilesätze und 20 einzelne Platinen in Umlauf gelangt. Details zu den Bestellungen und teils auch zur Hardware finden sich im [http://www.mikrocontroller.net/topic/86889 Forum].

== Hardware ==
'''Allgemein'''

Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils nur optischer Natur sind. Diese überarbeitete Version ist [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip hier] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

'''Bauteile'''

Leider ist es nicht ganz einfach an die Bauteile zu kommen. Bei den Sammelbestellungen wurde das "Hühnerfutter" bei Reichelt, das SRAM bei EBV und die restlichen Teile bei Digikey bestellt.

Bzgl. SRAM wurde seinerzeit nach passenden Typen gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Bezugsquellen für die Teile:
* Hühnerfutter für o.g. Version inkl. LPT: http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084
* Hühnerfutter inkl. LPT & USB: http://www.reichelt.de/?ACTION=20;AWKID=45435;PROVID=2084
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144). Zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bereits erfolgreich eingesetzte SRAMs:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität
*Größe (>= 128k)
*Datenbreite (>= 32bits)
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag in der [http://www.mikrocontroller.net/topic/93848 Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip hier] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* Projekt-Seite: http://minila.sourceforge.net
* Bob Grieb's Version (Basis der Sammelbestellungen): http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw
* Überarbeitete Version davon (inkl. Stückliste): http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip
* Eagle-Projekt für martiniman's Programmer: http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip
* Diskussion zur Sammelbestellung: http://www.mikrocontroller.net/topic/86889
* Diskussion zur PC-Software: http://www.mikrocontroller.net/topic/93848
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [http://www.mikrocontroller.net/articles/Logic_Analyzer Logic Analyzer]

== ToDo ==
* Informationen zu den "Tastköpfen" fehlen
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]

MiniLA

2009-02-13T21:03:50Z

Kichi:

[[Image:Minila_best_top.jpg|thumb|300px|right]]
[[Image:Minila_best_bot.jpg|thumb|300px|right]]
''von Michael K.''

== Einleitung ==
Diese Seite soll eine Art Informationssammlung zum Open-Source-Logic-Analyzer "miniLA" werden um potentielle "Nachbauer" zu unterstützen. Die zugehörigen Threads im Forum sind inzwischen sehr umfangreich und dadurch leider auch etwas unübersichtlich geworden.

Die Features das Gerätes sind auf der [http://minila.sourceforge.net Projekt-Homepage] zu finden.

Es gab hier im Forum zwei Sammelbestellungen zur Platine und den nötigen Bauteilen. Die erste fand Anfang 2008, die andere im Herbst 2008 statt. Insgesamt sind dabei etwa 40 Teilesätze und 20 einzelne Platinen in Umlauf gelangt. Details zu den Bestellungen und teils auch zur Hardware finden sich im [http://www.mikrocontroller.net/topic/86889 Forum].

== Hardware ==
'''Allgemein'''

Bei den Sammelbestellungen wurde jeweils die Version von [http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw Bob Grieb] bestellt, bei der der USB-Anschluss direkt integriert ist. Wird dieser nicht benötigt, so werden die entsprechenden Teile einfach nicht bestückt.

Es wurden einige Veränderungen und Korrekturen am Layout durchgeführt, die jedoch teils nur optischer Natur sind. Diese überarbeitete Version ist [http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip hier] zu finden. Details zu den Änderungen können in der enthaltenen "README2_v1.txt" nachgelesen werden.

Der Schaltplan wurde mit [http://www.mikrocontroller.net/articles/Schaltplaneditoren#TinyCAD TinyCAD] und das Layout mit [http://www.freepcb.com FreePCB] erstellt.

'''Bauteile'''

Leider ist es nicht ganz einfach an die Bauteile zu kommen. Bei den Sammelbestellungen wurde das "Hühnerfutter" bei Reichelt, das SRAM bei EBV und die restlichen Teile bei Digikey bestellt.

Bzgl. SRAM habe wurde seinerzeit nach passenden Typen gesucht und die Ergebnisse in eine [http://www.mikrocontroller.net/attachment/30530/sram3.xls Excel-Liste] eingetragen. Auf Vollständigkeit, Richtigkeit und Aktualität kann es jedoch leider keine Garantie geben.

Bezugsquellen für die Teile:
* Hühnerfutter für o.g. Version inkl. LPT: http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084
* Hühnerfutter inkl. LPT & USB: http://www.reichelt.de/?ACTION=20;AWKID=44322;PROVID=2084
* SRAM (Samsung K7B803625B-PI65): http://www.ebv.com (Gewerbe nötig)
* Restliche Teile: http://www.digikey.de

Die beiden Reichelt-Warenkörbe sind unter Umständen nicht mehr ganz aktuell und sollten deswegen unbedingt mit der Stückliste (siehe ZIP-File oben bzw. unten) abgeglichen werden. Bitte ggf. hier auf Fehler bei den Warenkörben hinweisen oder [http://www.mikrocontroller.net/user/show/kichi Michael K.] diesbezüglich benachrichtigen!

Bei der Bauteil-Auswahl gibt es nicht sehr viel zu beachten, lediglich CPLD, SRAM und der Multiplexer sind etwas kritischer. Beim CPLD muss es sich um einen Typ mit Speed-Grade 6 handeln (XC95288XL-6..., TQFP144). Zur Auswahl von SRAM und HC4053 gibt es ein paar Anmerkungen in der "mlaUSBbom_v1.txt" und in der "README2_v1.txt".

Bereits erfolgreich eingesetzte SRAMs:
*K7B803625B-PI65
*CY7C1361B-133AC
*IS64LF12832A-7 (lt. miniLA-Entwickler)

Die wichtigen Kriterien beim SRAM sind:
*Pin-Kompatibilität, Größe (Kapazität), Datenbreite (>=32 bits)
*Flow-Through-Modus
*cycle time < 10ns
*data setup time <= 2ns
*data hold time <= 2ns

== Firmware / Software ==
Als Firmware und Software kommen die Original-Versionen der Projekt-Seite zum Einsatz. Desweiteren gibt es bzgl. der PC-Software einen Beitrag in der [http://www.mikrocontroller.net/topic/93848 Codesammlung].

Zur [http://www.mikrocontroller.net/articles/Programmierbare_Logik#Konfiguration_.28Download.29_Xilinx Programmierung] des [http://www.mikrocontroller.net/articles/CPLD CPLD] wird ein Xilinx-JTAG-Programmer benötigt, welcher sehr einfach nachgebaut werden kann - leider nur für den Parallel-Port. Die Original-Version von Xilinx, auf die von der miniLA-Seite aus verwiesen wird, ist allerdings nur eingeschränkt zu empfehlen, da einige Nutzer Probleme damit haben/hatten. [http://www.geocities.com/jacquesmartini/digital/schematic/Parallel_Cable_III.png Martiniman's Version] sollte besser und zuverlässiger sein. Schaltplan und Layout dieser Version für Eagle können [http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip hier] heruntergeladen werden.

== Siehe auch ==
Nachfolgend eine Zusammenfassung der relevanten Links und Daten:
* Projekt-Seite: http://minila.sourceforge.net
* Bob Grieb's Version (Basis der Sammelbestellungen): http://minila.sourceforge.net/hw/other/bg/bg.php?id=hw
* Überarbeitete Version davon: http://www.mikrocontroller.net/wikifiles/a/ac/Minila%26usb-v1.zip
* Eagle-Projekt für martiniman's Programmer: http://www.mikrocontroller.net/wikifiles/8/88/Xilinx_programmer.zip
* Diskussion zur Sammelbestellung: http://www.mikrocontroller.net/topic/86889
* Diskussion zur PC-Software: http://www.mikrocontroller.net/topic/93848
Und noch ein paar allgemeine Links zum Thema Logic Analyzer:
* Artikel: [http://www.mikrocontroller.net/articles/Logic_Analyzer Logic Analyzer]

== ToDo ==
* Informationen zu den "Tastköpfen" fehlen
* Ggf. eine kleine Anleitung zum Programmieren des CPLDs schreiben

[[Category:Projekte]] [[Category:FPGA und Co]]