Mikrocontroller.net - Benutzerbeiträge [de]

VHDL Code Style und DO-254

2015-04-08T09:43:14Z

217.86.180.189: Typos, format

''von [[Benutzer:Fpgakuechle]] (Volker Urban)''

Status: 2015-04-07, vollständig aber Codebeispiele fehlen und Einführung ist ein bisserl knapp

=Checkliste für FPGA (VHDL)-Designs (nach DO-254)=
Die DO-254 ist ein Standard zur Zertifizierung komplexer digitaler Schaltungen für Fluggerät - Avionik.
Die DO-254 usergroup hat in diesem Zusammenhang folgende Regel erarbeitet.

==VHDL Schreibstil - Coding Practice (CP)==
===Vermeide Fehler bei Typ_Deklarationen (CP1)===
*''Kontrolliere den Code auf inkorrekten Gebrauch von Typen, nichtpassende Begrenzungen oder Randbedingungen.''
*Schweregrad: Error

===Vermeide doppelte Signalzuweisungen (CP2)===
*''Ein Signal soll innerhalb eines Statementsbereich nur einmal zugewiesen werden.''
*Schweregrad: Error

<syntaxhighlight lang="vhdl">
IF reset = 1 then
ausgang <= '1' ;
blablup <= blupbla;
ausgang <= '0';
else
</syntaxhighlight>

===Vermeide numerischen Werte mitten im Code (CP3)===
*''Für Re-Use und einfacher Portierbarkeit sollten keine hart-codierte Zahlenwerte benutzt werden.''
*Schweregrad: Warning

===Vermeide vectorlängenabhängige Zuweisungen (CP4)===
*''Für Zuweisung während Reset keine hart-codierten Zahlenwerte verwenden''
*Schweregrad: Note

Statt
<syntaxhighlight lang="vhdl">
data <= "00000000";
</syntaxhighlight>
besser:
<syntaxhighlight lang="vhdl">
data <= (others => '0)";
</syntaxhighlight>

===Stelle sicher das alle FSM einheitlichen codiert sind (CP5)===
*''a: In einem Design sollte ein einheitlichen Stil für alle Zustandsautomaten verwendet werden.''
*''b: der FSM Zustand sollten nicht hart codiert sein, außer unvermeidbar.''
*Schweregrad: Error

===Stelle sicher das die Zustandsübergänge sicher sind (CP6)===
*''a: Ein Zustandsautomat sollte einen definierten Reset-Zustand haben.''
*''b: Alle ungenutzen (illegale oder undefinierte) Zustände sollen in einen definierten Zustand übergehen. In diesem Zustand soll die fehlerursache angemessen bearbeitet werden''
*''c: Es sollen keine unerreichbaren und keine Sackgassen-Zustände in einem Zustandsautomaten geben.''
*Schweregrad: Error

===Vermeide unstimmige Intervallgrenzen (missmatching ranges) (CP7)===
*''Bit-breiten an beiden Seiten einer Zuweisung, Vergleich oder Assoziation sollten übereinstimmen.''
*Schweregrad: Warning

===Stelle sicher das die Sensitivity list vollständig ist (CP8)===
*''Die sensetivity list sollte nur im process verwendete Signale enthalten.''
*Schweregrad: Warning

===Stelle sicher das Unterprogramme ordentlich sind (CP9)===
''Jedes Unterprogramm soll:''
*''nur einen Entrittspunkt,''
*''keine Rekursion,''
*''nur Zugriff auf lokale Variablen/Signale haben.''
*Schweregrad: Warning

===Weise Werte vor Nutzung zu (CP10)===
*''Jedem Objekt (Signal, Variable, Anschluß) sollte eine Wert zugewiesen werden bevor es benutzt wird.''
*Schweregrad: Warning

===Vermeide offene Eingänge (CP11)===
*''Jeder Eingang sollte von einem Anschluss, Signal oder Konstante getrieben werden.''
*Schweregrad: Error

===Vermeide offene Ausgänge (CP12)===
*''Design Ausgänge sollten verbunden sein''
*Schweregrad: Note

===Deklariere Objekte vor Nutzung (CP13)===
*''Objekte sollte vor der Benutzung deklariert werden''
*Schweregrad: Error

===Vermeide Ungenutzte Deklarationen (CP14)===
*''Alle deklarierten Objekte sollten benutzt werden.''
*Schweregrad: Warning

==Taktübergange - Clock Domain Crossing (CDC)==
===Analysiere Mehrfache asynchrone Takte (CDC-1)===
*''Für jedes Design das mehrere zueinander asynchrone Takte hat ist eine umfassende Analyse der Taktübergänge durchzuführen.''

==Sichere Synthese - Safe Synthesis (SS)==
===Vermeide implizierte Logik (SS1)===
*Erlaube keinen Code der feed-throughs, Schieberegister und interne Tristate-Treiber impliziert.

===Stelle ordentliche Case-Anweisungen sicher (SS2)===
''Case statements sollen:''
*''a) Vollständig sein,''
*''b) keine doppelten oder überlappenden Anweisungen enthalten,''
*''c) keine nichterreichbare Anweisungen enthalten,''
*''d) immer eine "when others" Regel enthalten.''
*Schweregrad: Error

===Vermeide Kombinatorische Rückkoppelungen (SS3)===
*''In einem kombinatorischen Prozess ist kein Lesen und Zuweisen desselben Signals zulässig.''
*Schweregrad: Error

===Vermeide automatische Einführung von latches (SS4) ===
*Der Codierstil sollte den automatischen Einbau von Latches verhindern.
*Schweregrad: Warning

===Vermeide mehrfache Wellenformen (SS5) ===
*Nur eine Waveform soll auf der rechte Seite nur eine Wellenform haben.
<syntaxhighlight lang="vhdl">
write <= '1' after clk_prd, '0' after 8*clk_prd;
</syntaxhighlight>
*Schweregrad: Error

===Vermeide mehrfache Signaltreiber (SS6) ===
''*Ein Signal/Variable soll nur in einem einzigen sequentiellen Block zugewiesen werden.''
*Schweregrad: Error

=== Vermeide uninitialisierte VHDL Konstante (SS7) ===
*''Stelle sicher das alle VHDL Konstanten initialisiert werden.''
*Schweregrad: Warning

=== Vermeide die Nutzung des Taktes als Data (SS8)===
*''Takt-Signale sollen nicht in einem Logik-pfad den Daten-Eingang eines FlipFlops treiben.''
*Schweregrad: Fehler

=== Vermeide gemeinsame genutzte Takt und Resetsignal (SS9) ===
*''Ein Signal sollte nicht sowohl als Takt und auch als Resetsignal benutzt werden.''
*Schweregrad: Error

=== Vermeide geschaltetet Takte (SS10) ===
*''Datensignale sollten nicht in einen Logik-Pfad benutzt werden, der den CLK-Eingang eines Registers treibt.''
*Schweregrad: Warning

=== Vermeide intern generierte Takte (SS11) ===
*''Vermeide intern generierte Taktsignale.''
*Schweregrad: Warning

=== Vermeide intern generierte Reset (SS12) ===
*''Vermeide intern generierte Reset, außer sie sind ordentlich isoliert.''
*Schweregrad: Warning

=== Vermeide Resets unterschiedlicher Polarität (SS13) ===
*''Ein und dasselbe Resetsignal sollte nicht mit unterschiedlicher Polarität oder Stil benutzt werden.''
*Schweregrad: Warning

=== Vermeide Register ohne Reset (SS14) ===
*''Alle Register sollten eine reset-Steuerleitung haben.''
*Schweregrad: Warning

=== Vermeide asynchrone deaktivierten Reset (SS15) ===
*''Resets sollten synchron freigegeben werden.''
*Schweregrad:Fehler

=== Vermeide Zuweisung bei der Initialisierung (SS16) ===
*''Verwende keine Register Initialisierung.''
*Schwerergrad: Error

=== Vermeide Logik ohne Treiber oder Nutzung (SS17) ===
*''a) Jedes Register oder Latch muss benutzt und getrieben werden.''
*''b) Register und latches die nur unebenutzte Logik treiben müssen untersucht werden.''
Schweregrad:Error

=== Stelle sicher das Register steuerbar bleiben (SS18) ===
*''Jedes Register soll über seine Eingänge steuerbar sein.''
*Schweregrad: Warning

=== Vermeide Schlangengleiche Verdrahtungen (SS19) ===
*''Kombinatorische Pfade sollen nicht tiefer als eine vorgegebenes maximale Logiktiefe sein.''
*Schweregrad: Warning

=== Stelle Grenze für Verschachtelungen sicher (SS20) ===
*''Bedingte Verzweigungen sind nur bis zu einer maximalen Verschachtelungstiefe gestattet.''
*Schweregrad: Warning

=== Stelle stets gleiche Richtung der Vektorindizierung sicher (SS21) ===
*''Benutze die selbe Multi-Bit Vektor Indizierung ("downto" vers. "to") im gesamten Design einheitlich.''
*Schweregrad: Warning

== Code-Durchsichten - Design Reviews (DR)==
=== Verwende Labels für Staements (DR1) ===
*''Case-Konstrukte, Always und initial blocks sollen Labels haben.''
*Scheregrad: Note

=== Vermeide gemischte Groß-/Kleinschreibung zur Unterscheidung (DR2)===
*''Namen sollen nicht allein durch Groß und Kleinschreibung unterscheidbar sein.''
*Schweregrad: Warning

=== Stelle eindeutige Namensräume sicher (DR3)===
*''Der selbe Name soll nicht für verschiedenen Typen von Identifiers benutzt werden.''
*Schweregrad: Error

=== Nutze "Trennenden Deklarations Stil" (DR4)===
*''Eine Zeile pro Deklaration.''
*Schweregrad: Note

=== Nutze "Trennenden Statement Stil" (DR5)===
*''Eine Zeile pro Anweisung.''
*Schweregrad:Note

=== Stelle einheitlichen Einrückungen sicher (DR6)===
*''Code soll einheitlich eingerückt sein.''
*Schweregrad: Note

=== Vermeide Tabulatoren (DR7) ===
*''Tabulatoren sollen nicht benutzt werden.''
*Schweregrad: Note

=== Vermeide lange Files (DR8)===
*''Das Design soll in Unterdesigns gegliedert sein und Dateien sollen nicht nach Belieben lang sein.''
*Schweregrad: Warning

=== Stelle über Hierarchien einheitliche Signalnamen sicher (DR9)===
*''Signale und Busse sollen über das gesamte Design einheitliche Namen haben.''
*Schweregrad: Warning

=== Stelle einheitlichen Datei-Header sicher (DR10) ===
*''Stelle einheitliche File Header sicher.''
*Schweregrad: Warning

=== Stelle ausreichende Kommentardichte sicher (DR11) ===
*''Code soll durch inline Kommantare ausreichend dokumentiert sein.''
*Schweregrad: Warning

=== Stelle ordentliche Paltzierung von Kommentaren sicher (DR12) ===
*''Kommentare sollten so platziert sein das sie das Verständniss unterstützen.''
*Schweregrad: Note

=== Stelle Firmenspezifische Namensstandard sicher (DR13) ===
*''Jede Firma oder project soll ihre eigenen Codestandards definieren und durchsetzen.''
*Schweregrad: Note

=Literatur=
*[DOUG] DO-254 User Group Position Paper DO254-UG-001 „Best PracticeVHDL Coding Standards for DO-254 Programs, modified 2010-Sep-13
*[Fulton] Randall Fulton, Ray Vandermolen „Airborne Electronic Hardware Design Assurance - A practitioners Guide to RTCA/DO-254“, CRC Press 2015
*[Synopsys] Synopsys Inc. White paper „Understanding DO-254 Compliance for the verification of Airborne Digital Hardware“

Codebase für LPC1xxx

2015-03-23T15:19:34Z

217.86.180.189: /* adcInit */ m1n0r typos

== Codebase für LPC11xx und LPC13xx ==
Für die Cortex-M0 und -M3 Familien existieren verschiedene Basispakete die als Startausstattung sehr gut geeignet sind. Auf microbuilder.eu findet man eine sehr interessante Version inklusive Dokumentation.

Neben weiteren, interessanten Infos findet man dort eine Beta-Version 0.8 für den '''[http://www.microbuilder.eu/Projects/LPC1114ReferenceDesign/LPC1114CodeBase.aspx LPC1114]''' vom 14. April 2012 (auch wenn dort 2011 steht!) und eine Beta-Version 1.1.1 für den '''[http://www.microbuilder.eu/Projects/LPC1343ReferenceDesign/LPC1343CodeBase.aspx LPC1343]''' vom 14. April 2012.

(Achtung: die aktuellste Version findet sich immer unter dem dort auch gezeigten "github"-Link)

Die Original-Dokumentation kann auf der rechten Seite unter "Code Base/Documentation" angewählt werden.

Natürlich können die Funktionen die unter LPC1343 gesammelt werden auch für z.B. den LPC1313 eingesetzt werden, jedoch könnte das Ergebnis beim ansprechen von eigentlich nicht vorhandener Peripherie unvorhersehbar sein.

Der hier folgende Text ist zum gegenwärtigen Zeitpunkt (Januar 2012) im Wesentlichen eine Übersetzung der Seite von microbilder.eu

== Allgemeine Informationen zum Aufbau der Code Base ==

Der Aufbau der Dateien wird am Beispiel für den weiter fortgeschrittenen Stand zur LPC13xx Familie beschrieben, sollte aber weitgehend auch für den LPC1114 anwendbar sein. Die Beispiele der Code-Base beziehen sich auf ein Referenzboard von "microbuilder.eu" das '''[http://www.microbuilder.eu/projects/LPC1343ReferenceDesign.aspx hier]''' verfügbar ist.

'''Download des im Folgenden beschriebenen Code-Packages als github-Zip [https://github.com/microbuilder/LPC1343CodeBase/zipball/master hier]... immer als aktuellste Version '''

Ziel ist, auf dem aktuellen Stand aufzusetzen, bereits vorhandene Grundfunktionen zu erweitern und neue hinzuzufügen, Mitarbeit ist herzlich willkommen.

=== Lizenz ===

Der Author, microBuilder SARL, hat seine Libs unter eine "modifizierte BSD-Lizenz gestellt", die Nutzung und Modifikation erlaubt, sofern der in jedem File enthaltene Paragraph zur
Lizenzbeschreibung erhalten bleibt. Details sind aus jedem beliebigen File der Code Base zu entnehmen.

=== Unterstütze Peripherieeinheiten ===
(Stand Januar 2012)

* CPU (vorerst nur auf 72MHz gesetzt)
* ADC (Analog zu Digital Konverter)
* GPIO (Standard Eingänge und Ausgänge)
* I2C (Generischer I2C Code, interrupt betrieben)
* PMU (Power Management, Sleep-Modi)
* PWM (Pulsweiten Modulation)
* SSP (Generischer SSP/SPI Code)
* Systick (Verwendung des 24-bit Systick Timers)
* Timer16 (Die 16-bit Timer)
* Timer32 (Die 32-bit Timer)
* UART (UART code, interrupt betrieben)
* USBCDC (USB / Serial Port Emulation)
* USBHID-ROM (ROM-based USB HID)
* WDT (Watchdog Timer)

=== Enthaltene Treiber für externe HW ===
(Stand Januar 2012)

* EEPROM/AT25040 (SPI EEPROM)
* EEPROM/MCP24AA (I2C EEPROM)
* SENSORS/LM75B (I2C Temp Sensor)
* CHIBI - Ein einfacher, Open Source Wireless Stack von Freaklabs für Sensorknoten. In diesem Beispiel für den AT86RF212 Transceiver (868MHz) konfiguriert.
* FATFS - Eine Portierung von Chan's FATFS das bereits FAT32, und einen einfachen MMC Treiber zum lesen von SDHC Karten beinhaltet
* ILI9325 - Treiber für einen auf ILI9325/ILI9328 Controller (8-bit Interface erforderlich) basierten 240x320 TFT LCD.
* ST7565 - Treiber für ein 128x64 pixel Bitmap Display
* SSD1306 - Treiber für ein 128x64 OLED Display (bit-banged SPI mode)
* TCS3414 - TAOS RGB Sensor
* ISL12022M - Temperaturkompensierter RTC
* TSL2561 - TAOS Beleuchtungssensor
* PN532 - 13.56MHz RFID/NFC Transceiver (im moment mit serh limitierter Funktionalität)
* STEPPER - Basis Treiber für einen Bipolar Schrittmotor mit L293D oder SN754410N

== Struktur der Code Base ==
oder "wo finde ich was"

Die LPC1343 Code Base hat - nach einiger Gewöhnungszeit - einen recht einfachen Aufbau:
* Alle bauteilespezifischen Informationen incl. der internen Peripherie befinden sich im Verzeichnis "core".
* Treiber für externe HW ist im Verzeichnis "drivers" zusammengefaßt.
* Die Files zur Projekt- und Systemkonfiguration befinden sich im Root-Verzeichnis.

* Projektfiles für CodeLite (kostenlos) und Rowley Associates Crossworks (kommerziell) stehen im "build" Verzeichnis, und obwohl beide IDEs den gleichen Code verwenden können benutzen sie zum Compilieren nicht die gleiche Toolchain. "Crossworks for Arm" nutze eine eigene GCC Toolchain und einen eigenen Startup Code aber nicht das Makefile im Root-Verzeichnis. Mit CodeLite kann man auch ohne entsprechende Investitionen in HW und SW schon recht angenehm arbeiten

=== LPC134x.h===
Um den Umgang mit der Code Base so einfach wie möglich zu machen wurde ein neues Header-File erzeugt. Obwohl bereits diverse Header-Files für den LPC1343 existieren war der Wunsch die sogenannten "magic-numbers" im Code zu eliminieren. Daher wurde ein "eigenes" erzeugt.
Die 134x.h Datei enthält daher für fast jedes Bit das gesetzt oder gelöscht werden kann auch eine entsprechende Definition. Es bedeutet natürlich einen großen Arbeitsaufwand all diese Informationen in ein Header-File zu pakcen, das Resultat ist jedoch ein einfach lesbarer Code, speziell wenn jemand Anderer ihn geschrieben hat.

Was sind diese "Magic Numbers"?
Unter "Magic Numbers" versteht man hier den Zugriff auf ein Register ohne "define" also die direkte Angabe einer Zahl in beliebigem Format. Klar, die Eingabe ist kürzer und erzeugt den gleichen Code, aber welche Zeile ist wohl ein halbes Jahr später einfacher zu lesen??

<syntaxhighlight lang="c">
UART_U0LCR = 0x83;

UART_U0LCR = (UART_U0LCR_Word_Length_Select_8Chars |
UART_U0LCR_Stop_Bit_Select_1Bits |
UART_U0LCR_Parity_Disabled |
UART_U0LCR_Break_Control_Disabled |
UART_U0LCR_Divisor_Latch_Access_Enabled);

</syntaxhighlight>

===projectconfig.h===

"projectconfig.h" enthält diverse Aufzählungen die innerhalb eines Projektes benutzt werden wie eine Übersicht über die verwendeten Pins, die CPU_Clock, die Zeit für den System-Tick, Baudraten, SSP, USB, ...

===Core Peripherie (core/...)===

Alle Funktionen zum initialisieren der internen Peripherie sowie ein kleines Beispiel ist im Verzeichnis "core" enthalten.

===External Hardware (drivers/...)===

Jeden Code, der mit der externen Hardware irgendwie interagiert findet man im Verzeichnis "drivers".

==Core/CPU==

Die maximale Taktfrequenz des LPC1343 ist 72MHz. Beim Start-Up ist automatisch die max. Taktfrequenz (72MHz), und ein externer Quarz mit 12MHz eingestellt.
(Der LPC13xx enthält auch einen internen 12MHz Oszillator, der aber nicht so genau wie ein externer Quarz sein kann. Für USB ist die Genauigkeit definitiv nicht ausreichend.)
Um den Stromverbrauch zu minimieren werden alle Pins auf GPIO und "Eingang" gesetzt. Der interne Pull-Up Widerstand ist dabei immer in "pull up" Modus. Dies bedeutet, daß alle Pins nach dem Start der CPU auf "High" gesetzt sind.
Um diese Voreinstellungen zu ändern muß cpuInit entsprechend angepaßt werden.

===cpuInit===
void cpuInit (void)

Initialisiert die System-Taktfrequenz, auf max. Speed (12MHz x 6 = 72MHz)und benutzt einen externen Quarz als Taktquelle. Dies sollte die erste Funktion sein, die ausgeführt wird, da sich die CPU sonst nicht wie erwartet verhalten wird. Alle Pins sind auf GPIO mit aktiviertem internen Pull-up gesetzt.

Übergabeparameter: Keine

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"

int main(void)
{
cpuInit();

// Enter permanent loop
while(1);
}</syntaxhighlight>

===cpuGetDeviceID===
cpuDeviceID_t cpuGetDeviceID (void)

Liest die CPU-ID aus
Übergabeparameter: Keine

Rückgabewert:

cpuDeviceID_LPC1311,
cpuDeviceID_LPC1313,
cpuDeviceID_LPC1342,
cpuDeviceID_LPC1343 oder
cpuDeviceID_Unknown

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"

int main(void)
{
cpuInit();

cpuDeviceID_t id = cpuGetDeviceID();

if (id == cpuDeviceID_LPC1343)
{
// Part is either LPC1343FBD48 or LPC1343FHN33
}

// Enter permanent loop
while(1);
}</syntaxhighlight>

==Core/ADC==

Der LPC1343 enthält einen 8-Kanal, 10-Bit Analog/Digital Wandler (ADC), der zwischen 0 und 3,6V messen kann. (Achtung: Vcc - meist 3,3V - nicht überschreiten. Jeder Kanal kann separat, oder alle 8 Kanäle nacheinander im
'Burst' Mode gewandelt werden. Derzeit ist der 'Burst' Mode nicht in SW umgesetzt.

===adcInit===
void adcInit (void)

Initialisiert den A/D Konverter und konfiguriert die Kanäle 0..3 für 10-Bit.
Übergabeparameter: Keine

Siehe Beispiel für adcRead

===adcRead===
uint32_t adcRead (uint8_t channelNum)

Diese Funktion startet eine AD-Wandlung für einen einzigen Kanal (0..7) und gibt das Ergebnis zurück (0..1023).
Übergabeparameter:

* uint8_t channelNum: Der Kanal [0..7] der abgetastet werden soll

Rückgabewert:

0, wenn ein Überlauf entsteht, ansonsten ein 10-Bit Wert der das Ergebnis der Wandlung enthält.

Warnung:
In adcInit werden nur die Kanäle 0..3 als AD-Wandler Input konfiguriert.

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/adc/adc.h"

void main (void)
{
cpuInit();
adcInit();

uint32_t results = 0;
while(1)
{
// Get A/D conversion results from A/D channel 0
results = adcRead(0);
}
}</syntaxhighlight>

==Core/GPIO==

GPIO (General Purpose Input/Output) bezeichnet einen digitalen Ein-/Ausgang (I/O). JederPin kann unabhängig von Anderen beliebig als Eingang oder als Ausgang konfiguriert werden. Zusätzlich kann jeder GPIO Pin am LPC13xx als externer Interrupt Eingang konfiguriert werden. Wenn sich ein Pegel an einem solchen Pin ändert wird. Zusätzlich besitzt jeder GPIO einen internen Widerstand, der sowohl als Pull-up, als Pull-down oder als Repeater konfiguriert werden kann. Dieser interne Widerstand ist auch abschaltbar. Details hierzu bitte im Datenblatt nachschlagen. Dieser Widerstand sorgt nicht nur für eine Verringerung der erforderlichen Bauteile für so ein System, er erhöht außerdem die Flexibilität, erfordert aber auch mehr Sorgfalt bei der Pinkonfiguration

===gpioInit ===
void gpioInit (void)

Initialisiert GPIO und schaltet den GPIO interrupt handler für alle GPIO Ports ein.
Übergabeparameter: Keine

Siehe Beispiel für gpioSetValue

===gpioSetDir ===
void gpioSetDir (uint32_t portNum, uint32_t bitPos, gpioDirection_t dir)

Setzt die Richtung (input/output) für einen bestimmten Port Pin.
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]
* dir: die Pin Richtung (gpioDirection_Input or gpioDirection_Output)

Siehe Beispiel für gpioSetValue

===gpioSetValue ===
void gpioSetValue (uint32_t portNum, uint32_t bitPos, uint32_t bitVal)

Setzt einen Wert für einen bestimmten Port Pin (nur relevant, wenn eder Pin als Ausgang konfiguriert wurde).
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]
* bitVal: Enthält den neuen Pegen high (1) oder low (0).

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
cpuInit();
gpioInit();

// Set GPIO1.8 to output
gpioSetDir(1, 8, gpioDirection_Output);
// Disable the internal pullup/down resistor on P1.8
gpioSetPullup(&IOCON_PIO1_8, gpioPullupMode_Inactive);
// Set GPIO1.8 high
gpioSetValue(1, 8, 1);

while(1);
}</syntaxhighlight>

===gpioGetValue===
uint32_t gpioGetValue (uint32_t portNum, uint32_t bitPos)

Liest einen bestimmten Port Pin aus.
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]

Rückgabewert:

1 wenn der Pin gerade high, oder 0 wenn der Pin gerade low ist.
Warnung:

Alle GPIO Pins des LPC1343 haben interne Pull-up/Pull-down widerstände die beliebig konfiguriert werden können. By default, schaltet der LPC1343 nach dem Reset die pull-up Widerstände an den meisten Pins EIN. Hintergrund dieser Vorgehensweise ist, daß der Stromverbrauch geringer ist, wenn die Pins einen definierten Pegel haben, statt zu "floaten". Dies hat jedoch den Nachteil, daß der zurückgelesene Pegel nicht unbedingt mit dem erwarteten Pegen zu tun haben muss.

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
cpuInit();
gpioInit();

// Set GPIO1.8 to input
gpioSetDir(1, 8, gpioDirection_Input);
// Disable the internal pullup/down resistor on P1.8
gpioSetPullup (&IOCON_PIO1_8, gpioPullupMode_Inactive);

uint32_t results = 0;
while(1)
{
// Read the current state of GPIO1.8 (1 = high, 0 = low)
results = gpioGetValue(1, 8);
}
}</syntaxhighlight>

===gpioSetPullup ===
void gpioSetPullup (volatile uint32_t *ioconReg, gpioPullupMode_t mode)

Alle GPIO Pins des LPC1343 haben interne Pull-up/Pull-down widerstände die beliebig konfiguriert werden können. Diese Funktion kann dazu verwendet werden den Betriebsmodus der integrierten Widerstände auszufählen (inactive, pull-up, pull-down, or repeater)
Übergabeparameter:

* *ioconReg: Pointer auf das IOCON Register um den Pin zu wählen (zB. 'IOCON_PIO1_8' für GPIO 1.8, 'IOCON_PIO2_2' für GPIO 2.2, etc.). Achtung: Da dies ein Pointer ist, muß die Adresse (und nicht der Wert) des Registers übergeben werden. Dies wird erreicht in dem ein '&' vor das entsprechende IOCON Register gesetzt wird, z.B.: 'gpioSetPullup(&IOCON_PIO2_2, gpioPullupMode_Inactive);'.
* mode: Betriebsmodus des internen Widerstandes (gpioPullupMode_Inactive, gpioPullupMode_PullDown, gpioPullupMode_PullUp or gpioPullupMode_Repeater).

Warnung:
Der LPC13xx setzt den Pull-up Widerstand direkt nach dem Reset automatisch. ,
Um Schwierigkeiten zu vermeiden wird empfohlen alle Pins immer explizit zu definieren.

<syntaxhighlight lang="c">#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
cpuInit();
gpioInit();

// Set GPIO1.8, 1.9, 1.10 and 1.11 to input
gpioSetDir(1, 8, gpioDirection_Input);
gpioSetDir(1, 9, gpioDirection_Input);
gpioSetDir(1, 10, gpioDirection_Input);
gpioSetDir(1, 11, gpioDirection_Input);

// Enable the pull-down resistor on P1.8
gpioSetPullup (&IOCON_PIO1_8, gpioPullupMode_PullDown);
// Enable the pull-up resistor on P1.9
gpioSetPullup (&IOCON_PIO1_9, gpioPullupMode_PullUp);
// Disable the internal resistor resistor on P1.10
gpioSetPullup (&IOCON_PIO1_10, gpioPullupMode_Inactive);
// Set P1.11 to 'Repeater' (remembers the last state explicitly set)
gpioSetPullup (&IOCON_PIO1_11, gpioPullupMode_Repeater);

while(1);
}</syntaxhighlight>

===gpioSetInterrupt ===
void gpioSetInterrupt (uint32_t portNum, uint32_t bitPos, gpioInterruptSense_t sense, gpioInterruptEdge_t edge, gpioInterruptEvent_t event)

Jeder GPIO Pin des LPC1343 kann als externe Interrupt Quelle definiert werden. Die Funktion gpioSetInterrupt erlaubt die Festlegung, welcher Pin als Interruptquelle fungieren soll, und spezifiziert die Randbedingungen, unter denen ein Interrupt ausgelöst wird(Pin geht von H==>L oder von L==>H, ...). Abhängig von der portNum, wird der Interrupt durch den PIOINTx_IRQHandler gehandhabt , wobei 'x' der Portnummer entspricht (PIOINT1_IRQHandler wird benutzt wenn der Interrupt z.B. an GPIO Pin 1.8, ausgelöst wird).
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]
* sense: Flanken, oder Level-sensitive(gpioInterruptSense_Edge oder gpioInterruptSense_Level).
* edge: bei Flanke: Flanken-sensitive als Einfache Flanke (gpioInterruptEdge_Single) oder beide Flanken (gpioInterruptEdge_Double).
* event: bei Level:, High oder Low Level (gpioInterruptEvent_ActiveHigh) (gpioInterruptEvent_ActiveLow).

<syntaxhighlight lang="c">#include "core/cpu/cpu.h"
#include "core/gpio/gpio.h"

int main (void)
{
cpuInit();
gpioInit();

// Set GPIO1.8 to input
gpioSetDir(1, 8, gpioDirection_Input);
// Disable the internal pullup/down resistor on P1.8
gpioSetPullup (&IOCON_PIO1_8, gpioPullupMode_Inactive);
// Setup an interrupt on GPIO1.8
gpioSetInterrupt(1, // Port
8, // Pin
gpioInterruptSense_Edge, // Edge Sensitive
gpioInterruptEdge_Single, // Single Edge
gpioInterruptEvent_ActiveHigh); // Active High
// Enable the interrupt
gpioIntEnable(1, 8);

while (1);
}</syntaxhighlight>

===gpioIntEnable ===
void gpioIntEnable (uint32_t portNum, uint32_t bitPos)

Erlaubt einen Interrupt am spezifizierten GPIO-Pin.
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]

Siehe Beispiel für gpioSetInterrupt.

===gpioIntDisable ===
void gpioIntDisable (uint32_t portNum, uint32_t bitPos)

Schaltet einen Interrupt am spezifizierten GPIO-Pin aus.
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]

Siehe Beispiel für gpioSetInterrupt.

===gpioIntClear===
void gpioIntClear (uint32_t portNum, uint32_t bitPos)

Löscht den Interrupt am spezifizierten Pin. Diese Funktion sollte nur aus der Interrupt-Service Routine aufgerufen werden, wenn der Interrupt aufgetreten ist.
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]

<syntaxhighlight lang="c">
// IRQ Handler for GPIO Port 1
void PIOINT1_IRQHandler(void)
{
uint32_t regVal;

// Check if pin 1.8 raised the interrupt
regVal = gpioIntStatus(1, 8);
if (regVal)
{
// Do Something
...
// Clear the interrupt
gpioIntClear(1, 8);
}
return;
}</syntaxhighlight>

Siehe Beispiel für for gpioSetInterrupt to configure an interrupt.

===gpioIntStatus ===
uint32_t gpioIntStatus (uint32_t portNum, uint32_t bitPos)

Liest den Interrupt Status des spezifizierten Port-Pins.
Übergabeparameter:

* portNum: die gpio Port Nummer [0..3]
* bitPos: die Bit Position für den gpio pin [0..11]

Rückgabewert:

'1' wenn ein Interrupt an diesem Pin aufgetreten ist ansonsten '0'.

Siehe Beispiel für gpioIntClear.

==Core/PMU==

Konfiguriert die Power Management Unit (PMU) um den Sleep, Deep-sleep und Power-Down Modus. Jeder GPIO Pin kann so konfiguriert werden, um den Prozessor aus dem Sleep Mode aufzuwecken, aber nur ein low-level an Pin 1.4 (WAKEUP) kann den LPC aus dem Power-Down aufwecken.

===pmuInit===
void pmuInit(void)

Initialisiert die Power Management Unit und Konfiguriert Pin 0.1 so, da er als Wakeup-Quelle für Sleep oder Deep-Sleep Mode fungieren kann.
Übergabeparameter: Keine

Notes
Jeder GPIO Pin kann so konfiguriert werden, um den Prozessor aus dem Sleep Mode -- ausgelöst durch pmuSleep oder pmuDeepSleep-- aufzuwecken, aber nur ein low-level an Pin 1.4 (WAKEUP) kann den LPC aus dem Power-Down -- ausgelöst durch pmuPowerDown -- aufwecken.

Im oment ist nur P0.1 als Wakeup Quelle konfiguriert, aber in pmuSleep besteht die Möglichkeit durch auskommentieren beliebige, andere Pins zu wählen, sofern auch die entsprechende GPIO Konfiguration passend gesetzt ist.

Siehe Beispiel für pmuSleep, pmuDeepSleep and pmuPowerDown.

===pmuSleep===
void pmuSleep(void)

Diese Function versetzt den LPC in den Sleep Mode. Jeder GPIO-Pin kann verwendet werden um den LPC wieder aufzuwecken, der Pin muß entsprechend in pmuInit konfiguriert werden.
Übergabeparameter: Keine

<syntaxhighlight lang="c">#include "core/cpu/cpu.h"
#include "core/pmu/pmu.h"

int main(void)
{
cpuInit();

// Configure wakeup sources before going into sleep/deep-sleep.
// By default, pin 0.1 is configured as wakeup source (falling edge)
pmuInit();

// Enter sleep mode
pmuSleep();

while(1)
{
// Wait for an interrupt to wake the device up
}
}</syntaxhighlight>

===pmuDeepSleep===
void pmuDeepSleep( uint32_t sleepCtrl, uint32_t wakeupSeconds )

Diese Function versetzt den LPC in den Deep-Sleep Mode. AJeder GPIO-Pin kann verwendet werden um den LPC wieder aufzuwecken, der Pin muß entsprechend in pmuInit konfiguriert werden.
Der sleepCtrl Parameter wird benötigt umd festzulegen welche Peripherieeinheiten in den Sleep-Mode versetzt werden sollen, siehe SCB_PDSLEEPCFG Register für Details). Optional kann ein Wert ungleich null , in wakeupSeconds bereitgestellt werden, der den Prozessor nach der eingestellten Zeit wieder aufweckt. Dabei wird der 32-bit Timer 0 und Pin 0.1 (CT32B0_MAT2) benutzt.

Übergabeparameter:

* sleepCtrl: hierüber werden die gesetzten Peripherieeinheiten gezielt in Sleep-Mode gesetzt.
* wakeupSeconds: Ist dieser Wert größer 0 wird der Prozessor automatisch bach dieser Zeit in Sekunden wieder aufgeweckt.

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/pmu/pmu.h"

int main(void)
{
cpuInit();

uint32_t pmuRegVal;

// Configure wakeup sources before going into sleep/deep-sleep.
// By default, pin 0.1 is configured as wakeup source (falling edge)
pmuInit();

// Inidicate which peripherals should be disabled in deep-sleep
pmuRegVal = SCB_PDSLEEPCFG_IRCOUT_PD |
SCB_PDSLEEPCFG_IRC_PD |
SCB_PDSLEEPCFG_FLASH_PD |
SCB_PDSLEEPCFG_USBPLL_PD |
SCB_PDSLEEPCFG_SYSPLL_PD |
SCB_PDSLEEPCFG_SYSOSC_PD |
SCB_PDSLEEPCFG_ADC_PD |
SCB_PDSLEEPCFG_BOD_PD;

// Enter deep sleep mode and wakeup after 10 seconds
pmuDeepSleep(pmuRegVal, 10);

while(1)
{
}
}</syntaxhighlight>

===pmuPowerDown===
void pmuPowerDown( void )

Diese Function konfiguriert das PMU Control Register so, daß der LPC in den deep power-down mode geht. Achtung: Alle Register außer der vier Register (PMU_GPREG0..3) verlieren ihren Inhalt während der Prozessor im Deep-Power Down Mode ist. die 3,3V dürfen dazu nicht wegfallen
Übergabeparameter: Keine

Warnung:
Der LPC kann NUR durch einen Low-level an Pin P1.4 (WAKEUP aufgeweckt werden).

<syntaxhighlight lang="c">#include "core/cpu/cpu.h"
#include "core/pmu/pmu.h"

int main(void)
{
cpuInit();
pmuInit();

// Enter power-down mode
pmuPowerDown();

while(1)
{
// Device was woken up by WAKEUP pin
}
}</syntaxhighlight>

==Core/SSP==

Generischer Code für SSP/SPI Kommunikation. Der SSP Block wird als SPI Master Mode initialisiert

===sspInit ===
void sspInit (uint32_t portNum, sspClockPolarity_t polarity, sspClockPhase_t phase)

Initialisiert den SSP Port. By default, SSP wird als SPI frame-format mit 8-bit Data initialisiert. Pin 2.11 wird als serial clock (SCK) verwendet, und SSEL (0.2) ist als GPIO initialisiert, um manuell den SPI Port ein- bzw. Auszuschalten Überlauf und Timeout Interrupts sind beide ein.
Übergabeparameter:

* portNum: Port Number. ( Standardmäßig 0, es sei denn auf einem LPC1313/1.)
* polarity: Clock High (sspClockPolarity_High) oder Low (sspClockPolarity_Low)als inaktiven Pegel.
* phase: Bit Start mit steigender Flanke (sspClockPhase_RisingEdge) oder mit fallender Flanke sspClockPhase_FallingEdge) bei Pegelwechsel von SCK.

Notes

sspSelect() und sspDeselect() macros wurden ssp.h definiert, um SSEL kontrollieren zu können, ohne deß der dafür definierte Pin bekannt ist line
Siehe Beispiel für sspSend

===sspSend ===
void sspSend (uint32_t portNum, uint8_t *buf, uint32_t length)

Sendet einen Datenblock an den SSP Port
Übergabeparameter:

* portNum: Port Number. ( Standardmäßig 0, es sei denn auf einem LPC1313/1.)
* *buf: Pointer auf den Datenpuffer
* length: Block Länge des Datenpuffers

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/ssp/ssp.h"

#define SSP_FIFOSIZE 8

int main(void)
{
cpuInit();
sspInit(0, sspClockPolarity_High, sspClockPhase_RisingEdge);

uint8_t request[SSP_FIFOSIZE];
uint8_t response[SSP_FIFOSIZE];

// Send 0x9C to the slave device and wait for a response

// Fill request buffer
request[0] = 0x80 | 0x1C;

// Enable CS line
ssp0Select();

// Send the 'request' data (1 byte)
sspSend(0, (uint8_t *)&request, 1);

// Wait for the response (1 byte)
sspReceive(0, (uint8_t *)&response, 1);

// Disable CS line
ssp0Deselect();
}</syntaxhighlight>

===sspReceive===
void sspReceive(uint32_t portNum, uint8_t *buf, uint32_t length)

Empfängt einen Datenblock an den SSP Port
Übergabeparameter:

* portNum: Port Number. ( Standardmäßig 0, es sei denn auf einem LPC1313/1.)
* *buf: Pointer auf den Datenpuffer
* length: Block Länge des Datenpuffers

Siehe Beispiel für sspSend

==Core/Systick==

Steuert den 24-bit 'system tick' Timer, der sowohl als normaler Timer, alsauch als System-Timer für ein real-time Betriebssystem (FreeRTOS, Crossworks CTL, etc.) verwendet werden kann.

===systickInit ===
void systickInit (uint32_t delayMs)

Initialisiert den Systick Timer in Millisekunden (typischer Wert = 10ms). Dies führt alle z.B. 10ms zu einem Systtick Interrupt und dazu, daß eine unsigned 32-Bit Variable mit dem Namen "msTicks" um 1 hochgezählt wird wenn der Interrupt ausgelöst wird.
Übergabeparameter:

* delayMs: Indicates the length of time in millaseconds between each system 'tick'.

Siehe Beispiel für systickDelay.

===systickDelay ===
void systickDelay (uint32_t delayTicks)

Führt zu einem den Prozessor blockierenden Wartezeit von einer spezifizierten Anzahl an Systick Timer Ticks. Die Länge der Pause hängt von der in der systickInit Function definierten Interruptzeit ab.
Übergabeparameter:

* delayTicks: The number of systick ticks to wait.

<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/systick/systick.h"

int main (void)
{
// Initialise the cpu
cpuInit();
// Initialise the systick timer with one tick every 10 millaseconds
systickInit(10);

while(1)
{
// Wait 15 ticks on the systick timer (meaning 150ms)
systickDelay(15);
// Do something ...
}
}</syntaxhighlight>

==Core/Timer16==
Steuert alle 16-Bit Timers auf dem LPC1343. Achtung: bei 72MHz deckt ein 16-Bit Timer nur eine Zeit von knapp 0.91mS (or 910uS) ab:

1 mS = CFG_CPU_CCLK / 1000
= 72000000 / 1000
= 72000 'ticks'

Der Maximalwert eines 16-Bit Timers ist 0xFFFF (65535) also 0.910208ms.

===timer16Init===
void timer16Init(uint8_t timerNum, uint16_t timerInterval)

Initialisiert einen 16-bit timer mit seiner Interruptzeit. Jedes mal, wenn der Zeiraum abgelaufen ist wird der Timer-Interrupt ausgelöst, und die Zählervariable um eins hochgezählt. (z.B. mit Timer CT16B0, wird der 'timer16_0_counter' Inkrementiert).
Übergabeparameter:
* timerNum: Der 16-Bit Timer der initialisiert werden soll [0..1]
* timerInterval: Die Anzahl an Takt-'ticks' zwischen den Interrupts [0..65534]

Warnung
Vorsicht bei der Konfiguration der Timer, da die Pins mehrfach mit anderer Peripherie gemultiplext werden, je nach Initialisierung.Diese Funktion dient nur der besseren Veranschaulichung und muß unbedingt an die jeweiligen Randbedingungen angepaßt werden.

<syntaxhighlight lang="c">
#include "/core/cpu/cpu.h"
#include "/core/timer16/timer16.h"

// Instantiated in timer16.c
extern volatile uint32_t timer16_0_counter;

int main(void)
{
cpuInit();

// Initialise timer0 with a delay of 0xFFFF, which will cause the
// timer interrupt to fire every 65535 ticks and increment
// timer16_0_counter by 1
timer16Init(0, 0xFFFF);

// Enable the timer
timer16Enable(0);

// At this point timer16_0_counter should start incrementing by 1
// every 65535 ticks

while(1)
{
// If the timer has been fired 10 times, disabled the timer
if (timer16_0_counter == 10)
{
timer16Disable(0);
}
}
}</syntaxhighlight>

===timer16DelayTicks===
void timer16DelayTicks(uint8_t timerNum, uint16_t delayInTicks)

Führt zu einer blockierenden Pause für die definierte Anzahl an Takt-ticks.
Übergabeparameter:

* timerNum: Der 16-Bit Timer der initialisiert werden soll [0..1]
* delayInTicks: Anzahl an Takt ticks die pausiert werden soll [0..65534]

Notes
Die genaue Zeitdauer der Pause hängt von der Taktrate des System-Taktes ab.

<syntaxhighlight lang="c">
#include "/core/cpu/cpu.h"
#include "/core/timer16/timer16.h"

int main(void)
{
cpuInit();

// Initialise timer 0 ... delay is provided but not used here
timer16Init(0, 0xFFFF);

// Enable the timer
timer16Enable(0);

while(1)
{
// Cause blocking delay for 36000 ticks (0.5mS @ 72MHz)
// Note: The delay must be 65534 or less (16-bit value)
timer16DelayTicks(0, 36000);
}
}</syntaxhighlight>

===timer16DelayUS===
void timer16DelayUS(uint8_t timerNum, uint16_t delayInUS)

Führt zu einer blockierenden Pause für die definierte Anzahl an Mikrosecunden.
Übergabeparameter:

* timerNum: Der betreffende 16-Bit Timer [0..1]
* delayInUS: Anzahl der Mikrosekonden, die gewartet werden soll

Warnung
Die maximale Wartezeit bei 72MHz beträgt 910uS (0xFFFF / 72 = 910), or 0.91ms

<syntaxhighlight lang="c">
#include "/core/cpu/cpu.h"
#include "/core/timer16/timer16.h"

int main(void)
{
cpuInit();

// Initialise timer 0 ... delay is provided but not used here
timer16Init(0, 0xFFFF);

// Enable the timer
timer16Enable(0);

while(1)
{
// Cause blocking delay for 500 microseconds (0.5mS)
timer16DelayUS(0, 500);
}
}</syntaxhighlight>

===timer16Enable===
void timer16Enable(uint8_t timerNum)

Schaltet den spezifizierten Timer ein (erlaubt die Auslösung der konfigurierten Interrupts)
Übergabeparameter:

* timerNum: Der betreffende 16-Bit Timer [0..1]

Siehe Beispiel für timer16Init
void timer16Disable(uint8_t timerNum)

Schaltet den spezifizierten Timer aus (verbietet die Auslösung der konfigurierten Interrupts)
Übergabeparameter:

* timerNum: Der betreffende 16-Bit Timer [0..1]

Siehe Beispiel für timer16Init

===timer16Reset===
void timer16Reset(uint8_t timerNum)

Setzt den spezifizierten Timer zurück.
Übergabeparameter:

* timerNum: The 16-bit timer to reset [0..1]

==Core/Timer32==
Steuert alle 32-Bit Timers auf dem LPC1343.
Achtung: der 32-bit timers ermöglicht einen deutlich längeren Timerinterrupt als der 16-Bit Timer. z.B.

1 mS = CFG_CPU_CCLK / 1000
= 72000000 / 1000
= 72000 'ticks'

Der Maximalwert eines 32-Bit Timers ist, 0xFFFFFFFF (4,294,967,295), gleichbedeutend mit 59652ms (etwas weniger als eine Minute, im Vergleich ~0.91ms mit einem 16 Bit Timer @ 72MHz).

Sowohl die 16-Bit, alsauch die 32-Bit Timer können in verbindung mit einem externen Pin eingesetzt werden. z.B. setzen/löschen eines Pins, wenn ein "Match" eintritt. Jeses Matchregisters jedes Timers kann auch als PWM Register verwendet werden und ein entsprechendes PWM-Verhältnis ausgeben zu können.

===timer32Init===
void timer32Init(uint8_t timerNum, uint32_t timerInterval)

Initialisiert einen 32-bit timer mit seiner Interruptzeit. Jedes mal, wenn der Zeiraum abgelaufen ist wird der Timer-Interrupt ausgelöst, und die Zählervariable um eins hochgezählt. (z.B. mit Timer CT16B0, wird der 'timer16_0_counter' Inkrementiert).
Übergabeparameter:
* timerNum: Der 32-Bit Timer der initialisiert werden soll [0..1]
* timerInterval: Die Anzahl an Takt-'ticks' zwischen den Interrupts [0..4,294,967,294]

Warnung:
Vorsicht bei der Konfiguration der Timer, da die Pins mehrfach mit anderer Peripherie gemultiplext werden, je nach Initialisierung.Diese Funktion dient nur der besseren Veranschaulichung und muß unbedingt an die jeweiligen Randbedingungen angepaßt werden.

<syntaxhighlight lang="c">
#include "/core/cpu/cpu.h"
#include "/core/timer32/timer32.h"

// Instantiated in timer32.h
extern volatile uint32_t timer32_0_counter;

int main(void)
{
cpuInit();

// Initialise timer0 with a delay of 72000, which will cause the
// timer interrupt to fire every 1mS @ 72MHz and increment
// timer32_0_counter by 1
timer32Init(0, 72000);

// Enable the timer
timer32Enable(0);

// At this point timer32_0_counter should start incrementing by 1
// every 72000 ticks

while(1)
{
// If the timer has been fired 10 times, disabled the timer
if (timer32_0_counter == 10)
{
timer32Disable(0);
}
}
}</syntaxhighlight>

===timer32Delay===
void timer32Delay(uint8_t timerNum, uint32_t delay)

Führt zu einer blockierenden Pause für die definierte Anzahl an Takt-ticks.
Übergabeparameter:

* timerNum: Der 16-Bit Timer der initialisiert werden soll [0..1]
* delayInTicks: Anzahl an Takt ticks die pausiert werden soll

Notes
Die genaue Zeitdauer der Pause hängt von der Taktrate des System-Taktes ab.

Warning
Die max. delay-Zeit hängt von 'timerInterval' Wert ab, der bei der Timer initialisierung verwendet wird (siehe timer32Init).

<syntaxhighlight lang="c">
#include "/core/cpu/cpu.h"
#include "/core/timer32/timer32.h"

int main(void)
{
cpuInit();

// Initialise timer 0 with 1 millisecond 'ticks'
timer32Init(0, TIMER32_CCLK_1MS);

// Enable the timer
timer32Enable(0);

while(1)
{
// Cause a blocking delay for 1.5 seconds (1500 milliseconds)
timer32Delay(0, TIMER32_DELAY_1MS * 1500);
}
}</syntaxhighlight>

===timer32Enable===
void timer32Enable(uint8_t timerNum)

Schaltet den spezifizierten Timer ein (erlaubt die Auslösung der konfigurierten Interrupts)
Übergabeparameter:

* timerNum: Der betreffende 32-Bit Timer [0..1]

Siehe Beispiel für timer32Init

===timer32Disable===
void timer32Disable(uint8_t timerNum)

Schaltet den spezifizierten Timer aus (verbietet die Auslösung der konfigurierten Interrupts)
Übergabeparameter:

* timerNum: Der betreffende 32-Bit Timer [0..1]

Siehe Beispiel für timer32Init

===timer32Reset===
void timer32Reset(uint8_t timerNum)

Setzt den spezifizierten Timer zurück.
Übergabeparameter:

* timerNum: Der betreffende 32-Bit Timer [0..1]

==Core/UART==

Ermöglicht es einfache Teste über RS232, USB oder FTDI232RL zu senden oder zu empfangen. Jeder eingehende Text wird in einem FIFO gespeichert sodaß Datenverlust nicht auftreten sollte.

===uart_pcb_t===
uart_pcb_t *uartGetPCB ()

Liefert einen Pointer auf den Protokollblock des UART's. Damit kann der Status des UART ermittelt werden, und damit ob der UART initialisiert wurde, ob auf Daten gewartet oder gerade gesendet wird und um eine Referenz auf den Empfangs-FIFO zu erhalten.

Übergabeparameter: Keine
<syntaxhighlight lang="c">
// Make sure that UART is initialised
uart_pcb_t *pcb = uartGetPCB();
if (!pcb->initialised)
{
uartInit(CFG_UART_BAUDRATE);
}</syntaxhighlight>

===uartInit ===
void uartInit (uint32_t baudrate)

Initialisiert den UART mit einer spezifischen Baud-Rate.
Übergabeparameter:

* baudRate: Die Baud-Rate, mit der der UART konfiguriert werden soll (z.B. '57600').

<syntaxhighlight lang="c">#include "core/cpu/cpu.h"
#include "core/uart/uart.h"

#define UARTBUFFERSIZE 5

int main(void)
{
cpuInit();
uartInit(57600);

uint8_t uartBuffer[UARTBUFFERSIZE] = { 'T', 'e', 's', 't', '\n' };

while(1)
{
// Constantly send contents of uartBuffer
uartSend((uint8_t *)uartBuffer, UARTBUFFERSIZE);
}
}</syntaxhighlight>

===uartSend ===
void uartSend (uint8_t *bufferPtr, uint32_t length)

Sendet den Inhalt des Puffers über den UART.
Übergabeparameter:

* *bufferPtr: Pointer zum Text Buffer
* length: Die Größe des Text Buffers

Siehe Beispiel für uartInit

===uartSendByte ===
void uartSendByte (uint8_t byte)

Schickt ein einzelnes Byte an den UART.
Übergabeparameter:

* byte: Das zu sendende Byte
<syntaxhighlight lang="c">
// Send 0xFF over UART
uartSendByte(0xFF);

// Send 'B' over UART (note single quotes)
uartSendByte('B');</syntaxhighlight>

===uartRxBufferInit ===
void uartRxBufferInit ()

Initialisiert den RX FIFO buffer.
Übergabeparameter: Keine

No example current available.

===uartRxBufferRead ===
uint8_t uartRxBufferRead ()

Liest ein Byte aus dem RX Buffer. Diese Funktion liefert ein Byte zurück, das durch den Array Index spezifiziert wird. Erreicht der Pointer die max. Buddergröße, beginnt er wieder bei '0'.
Übergabeparameter: Keine

Siehe Beispiel für uartRxBufferWrite.

===uartRxBufferWrite===
void uartRxBufferWrite(uint8_t data)

Schreibt ein Byte in den RX Buffer.

Note: Normalerweise ist es nicht notwendig diese Funktion zu benutzen, da alle eingehenden Daten über den UART Interrupt laufen, und jedes Byte in den RX-Buffer geschrieben wird.
Übergabeparameter:

* uint8_t data: Byte, das in den RX Buffer geschrieben werden soll.
<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/uart/uart.h"

int main(void)
{
cpuInit();
uartInit(57600);

// Add 0xFF to the RX buffer
uartRxBufferWrite(0xFF);

// Check if the buffer is empty (it shouldn't be!)
while (uartRxBufferDataPending())
{
// Retrieve the first available character in the buffer
uint8_t c = uartRxBufferRead();
}

...
}</syntaxhighlight>

===uartRxBufferClearFIFO===
void uartRxBufferClearFIFO ()

Löscht die RX und TX Pointer und setzt die Längen auf Null.
Übergabeparameter: Keine

No example currently available.

===uartRxBufferDataPending===
void uartRxBufferDataPending()

Stellt fest, ob Daten im FIFO sind. Wenn ein odermehr Bytes im FIFO enthalten sind, wird eine '1' zurückgeliefert Ist der Puffer leern wird eine '0' zurückgeliefert.
Übergabeparameter: Keine

Siehe das Beispiel für uartRxBufferWrite.

==Core/USBHID-ROM==

Der LPC1343 enthält eine ROM-basierte Unterstützung für HID (Human Interface Device) und MSCD (Mass Storage Device) was einem eine relativ einfache Möglichkeit liefert USB Klassen schnell und effizient zu implementieren. Eine einfache HID implementierung ist in der Code-Base enthaltenund beinhaltet die Basis-Kommunikation zwischen dem LPC1343 und einem PC or USB-Host Device. In diesem Beispiel wird das Device so konfiguriert, daß "1-Byte! telegramme geschickt werden können. Achtung: dieses Beispiel ist auf das bei microbuilder.eu verfügbare LPC1343 Reference Board abgestimmt.

Dieser ROM-basierte HID Driver macht es wirklich außergewöhnlich bequem, ist aber weniger flexibel als ein vollständig SW-basierter USB/HID Stack.
Der Hauptunterschied ist, daß man hier auf einen "single Report" limitiert ist. Ein vollständig SW-basierter Stack ist auf der NXP-Website verfügbar. Ein möglicher Kompromiß zwischen Aufwand und flexibilität ist, daß z.B. immer zwei oder mehre Byte-Reports verschickt werden, wobei das erste Byte als eine adt "Komando-ID" bestimmt, wie die nachfolgenden Bytes interpretiert werden sollen. Speicher-Einschränkung: Der ROM-basierte HID Treiber verwendet 0x10000050 to 0x10000180 des On-Chip RAM, was bedeutet, daß im Linkter entsprechend eingestellt werden muß , daß diese Sektion nicht verwendet werden darf.

===usbHIDInit ===
void usbHIDInit (void)

Initialisiert das Device für USB HID Support und versucht einen Verbindungsaufbau zum Host. Das Device ist als 1 Byte Report konfiguriert.

Übergabeparameter: Keine
<syntaxhighlight lang="c">
#include "core/cpu/cpu.h"
#include "core/usbhid-rom/usbhid.h"
#include "core/gpio/gpio.h"

int main(void)
{
cpuInit();

// Set GPIO2.10 (LED) as output
gpioSetDir(2, 10, gpioDirection_Output);
// Disable LED (set high)
gpioSetValue (2, 10, 1);

// Initialise and connect USB
usbHIDInit();

// The device should enumerate on the PC, and
// the LED on 2.10 can be enabled by sending 0x01

while (1)
{
}
}</syntaxhighlight>

===usbHIDGetInReport ===
void usbHIDGetInReport (uint8_t src[], uint32_t length)

Setzt die HID im Report (vom LPC1343 zum USB host).
Übergabeparameter:

* src[]: Ein Byte-Array für die Report Daten
* length: Länge des src

Warnung
The signature for this method (uint8_t src[], uint32_t length) should not be modified, and this method should never be called directly. All interrupts and report exchanges are handled by the rom-based drivers. The only thing that should be modified in these methods is the code inside them that either generates or handles the appropriate byte data.
See the example for usbHIDInit

===usbHIDSetOutReport ===
void usbHIDSetOutReport (uint8_t dst[], uint32_t length)

Sezt den HID-out Report (Vom USB-Host zum LPC1343).
Übergabeparameter:

* src[]: Ein Byte-Array für die Report Daten
* length: Länge des src

Warnung
The signature for this method (uint8_t dst[], uint32_t length) should not be modified, and this method should never be called directly. All interrupts and report exchanges are handled by the rom-based drivers. The only thing that should be modified in these methods is the code inside them that either generates or handles the appropriate byte data.
See the example for usbHIDInit

==Core/WDT==

Der LPC1343 enthält einen Watchdog-Timer der benutzt werden kann das Sytem am laufen zu halten. Damit wird festgestellt, ob der LPC abgestürzt ist, oder nicht. Der 'Watchdog' ist so konfiguriert, daß er alle 'x' Ticks des System-Taktes getriggert werden muss. Wenn dies nicht stattfindet, können verschiedene Aktionen ausgelöst werden, (z.B. System-Reset, oder die Auslösung eines Interrupts). Die Grundeinstellung des in der Code-Base vorhandenen Codes setzt den Watchdog auf eine Togglerate von 250kHz, also einmal alle 250.000 Taktzyklen, und hier wird nur der WDT_IRQHandler ausgelöst.

===wdtInit ===
void wdtInit (void)

Initialisiert den Watchdog Timer und den interrupt.

Übergabeparameter: Keine

<syntaxhighlight lang="c">#include "core/cpu/cpu.h"
#include "core/wdt/wdt.h"

int main(void)
{
cpuInit();
wdtInit();

// Pat the watchdog to start it
wdtFeed();

while(1)
{
// Keep the watchdog happy by regularly feeding it
wdtFeed();

// Any delay here > 250,000 ticks (~3.5mS @ 72MHz)
// will cause the watchdog to raise an interrupt, which
// will be handled by WDT_IRQHandler
}
}</syntaxhighlight>

===wdtFeed ===
void wdtFeed (void)

Toggelt den Watchdog um einen Timeout zu verhindern.

Übergabeparameter: Keine

Siehe Beispiel für wdtInit

== Links ==

* [http://www.lpcware.com/lpcxpresso/home LPDXpresso Download (Kostenlos mit Debugger)]
* [http://www.lpcware.com LPCXpresso Homepage]
* [http://www.mikrocontroller.net/articles/LPC1xxx Beschreibung der LPC1xxx-Familie]
* [http://www.mikrocontroller.net/articles/LPC1xxx_Entwicklungskit_LPCXpresso LPCXpresso-Entwicklungskit]
* [http://www.mikrocontroller.net/articles/Installationsanleitung_C-Entwicklungsumgebung_f%C3%BCr_LPC1xxx_von_Code_Red Installationsanleitung zur IDE von Code-Red]

[[Kategorie:LPC1x]]

Xilinx Microblaze MCS Workflow

2015-03-11T17:25:43Z

217.86.180.189: /* Zusammenfügen FPGA bitstream und Executable zur downladbaren Datei */ Beschreibung

''Gestartet von [[Benutzer:Fpgakuechle]] (Volker Urban)''

Status: 2015-Feb-27 -> Material,Tips zur Fehlersuch und Screenshots sammeln

Der Artikel beschreibt wie der 32bit Softcore "microblaze MCS" in FPGA verwendet wird.
Verwendet wird dabei die kostenfrei verfügbare "leichtgewichtige" MicroBlaze-mcs (µB-MCS) Variante aus dem coregenerator (ab ISE 13.4 (ab 01/2013) und Vivado) und nicht die kostenpflichtige MicroBlaze (ohne -MCS) Variante.

=MicroBlaze und MicroBlaze MCS=

=Ablauf=
Die Implementierung eines FPGA-Systems mit Softcore verläuft in folgenden Phasen:
*Erstellung des FPGA-drumherum (Top-level design, pinassigments) und FPGA ohne microblaze-Core implementieren
*Generierung des Softcore im CoreGenerator
*Instanziierung Core, Script für bm referenz ausführen und FPGA mit microblaze-Core implementieren
*Erstellung der compilerumgebung (board support package, libraries, linkerscript)
*Erstellung und Kompilierung des Programms
*Zusammenfügen programm-binarie mit FPGA-bitstream file

=Benötigte Software=
Es wird von Xilinx die FPGA Implementierungssoftware und das Software Development Kit (SDK)benötigt. Nutzer der FPGA's vor der 7Serie (bspw Spartan3-Großfamilie, Spartan-6, Virtex5/6) muüßen installieren:
*ISE Design Suite: WebPack edition
*ISE Design Suite: Embedded edition
(Siehe http://www.xilinx.com/products/design-tools/ise-design-suite.html )

Nutzer der neueren 7er Reihe dagegen benötigen:
*Vivado Design Suite Webpack edition
(Siehe http://www.xilinx.com/products/design-tools/vivado.html)

=Beispiel=
Es wird ein einfacher Core mit 3 Ausgangsport a 8,4 und 6 bit, einem Eingangsport zu 8bit sowie einem Festwert- (FIT) und ein programmierbarer Zähler (PIT) generiert.
[[Datei:Mcs block.png|thumb|center|400px|Blockdiagramm Beispiel]]

Neben dem Core ist ein weitere Zähler -''heartbeat''- im Design. Die drei Ausgangsporst sind für das verwendete S3AN Starterkit verbunden mit dem Datenbus und den Steuerleitung des alphanumerischen Displays und den 6 LED rechts. Die LED Nr 8 wird von dem FPGA-Logiccounter zum blinken gebracht, LED nummero 7 vom toggle-signal des Festwertcounter. Damit lassen sich 3 Implementierungsziele detektieren.
*Nix blinkt -> Totalversagen
*LED Nr. 8 blinkt -> FPGA erfolgreich geladen und gestartet
*LED 8 und 7 blinken: -> microblaze ist erfolgreich im FPGA implementiert, aber das Programm läuft nicht.
*Aktivität auf allen 8 LED's -> Perfekt

=FPGA-Implementierung und SoftCore-Generierung=
==FPGA-Gerüst==
Es ist Empfehlenswert zuerst ein "Basis-FPGA" ohne µB fertigzustellen und zu testen. Hier wurde das zum Starterkit gehörige Demo adaptiert und somit war schon mal die Pinzuordnung und das Taktsystem fehlerfrei. Eine heartbeat-LED die im Sekundentakt blinkt grenzt den Fehler deutlich ein.

==CoreGen==
Coregen starten (beispw. Programme -> Xilinx -> ISE 14.7 -> ISE Design tools -> 64bit tools -> coregen) Project für den benutzen FPGA aufsetzen (hier im beispiel S3AN-700; package: FGG484; speedgrade 4 Verilog)

IM IP catalog findet sich der MCE unter embedded Processing -> processors -> microblaze MCE :
[[Datei:Ss coregen main.png|thumb|center|400px|CoreGen Auswahl microblaze MCS Core]]

Im Unterschied zum Screenshot sollte man den Speicher auf mindestens 8 kByte setzen. Die Angabe der Taktfrequenz ist für die Berechnung des Baudraten-teilers für die UART wichtig. Benutzt man die UART nicht, ist dieser Wert (theoretisch?) für den Core bedeutungslos. Das Place&Route für den FPGA richtet sich nach der Taktvorgabe aus dem ucf-file.
Die in den Karteikarten gezeigten Kürzel stehen für die einzigen "Peripheriecontrollern" die für dem µB-MCS generiert
werden können. Mit dem weiterhin kostenpflichten Platform Studio sind weitere Cores einfach hinzufügbar. Aber beim MCS muß man nicht komplett darauf verzichten da an dem IO-Bus selbtgeschriebene Komponenten angeschlossen werden können.

*UART: feste Baudrate, Interrupt für RX
*FIT: Fixed length timer -4 möglich
*PIT: programmable Timer - 4? möglich
*GPO: Generalpurpose Output-Port - 4 Ports mit jeweils 1-32 bit Breite Konfigurierbar
*GPI: Generalpurpose Input-Port - 4 Ports mit jeweils 1-32 bit Breite Konfigurierbar
*INT: External Interrupt Sources

Für die Treiber kann auch ein toggle output signal geriert werden das immer beim Erreichen der O invertiert wird.

[[Datei:Ss coregen generalsettings.png|thumb|center|400px|CoreGen Settings für microblaze MCS Teil 1]]
[[Datei:Ss coregen fitsettings.png|thumb|center|400px|CoreGen Settings für Fixed Timer]]
[[Datei:Ss coregen generated files.png|thumb|center|400px|Liste Generierter Dateien]]
[[Datei:Ss coregen info sdk.png|thumb|center|400px|Coregen Hinweis nächste Schritte]]
[[Datei:Ss coregen info tcl.png|thumb|center|400px|Coregen Hinweis Tcl-script]]
[[Datei:Ss tcl console.png|thumb|center|400px|Tcl-Console]]
==Vorbereitung Synthese mit MCS core==

==Top-Level==
<syntaxhighlight lang="verilog">
wire heartbeat_s;

wire [7:0] GPO1_s; //display data
wire [3:0] GPO2_s; //display control
wire [6:0] GPO3_s; // led's
wire [7:0] GPI1_s; //switches

wire FIT1_Toggle_s;

MikroBlaze_mcs microblaze_s3an_disp (
.Clk(clk), // input Clk
.Reset(rst), // input Reset
.FIT1_Toggle(FIT1_Toggle_s), // output fixed timer toggler (every 25M ticks)
.FIT2_Interrupt(/*FIT2_Interrupt*/), // UNUSED - output FIT2_Interrupt
.FIT2_Toggle(/*FIT2_Toggle*/), // UNUSED - output FIT2_Toggle
.PIT1_Interrupt(/*PIT1_Interrupt*/), // UNUSED - output PIT1_Interrupt
.PIT1_Toggle(/*PIT1_Toggle*/), // UNUSED - output PIT1_Toggle
.GPO1(GPO1_s), // output [7 : 0] GPO1
.GPO2(GPO2_s), // output [3 : 0] GPO2
.GPO3(GPO3_s), // output [6 : 0] GPO3
.GPI1(GPI1_s), // input [7 : 0] GPI1
.GPI1_Interrupt(/*GPI1_Interrupt*/), // UNUSED - output GPI1_Interrupt
.INTC_IRQ(/*INTC_IRQ*/) // UNUSED - output INTC_IRQ
);

always @(posedge clk)
begin

assign LCD_DB = GPO1_s[7:0];
assign LCD_RW = GPO2_s[0];
assign LCD_RS = GPO2_s[1];
assign LCD_E = GPO2_s[2];
end

heartbeat heartbeat(
.clk(clk),
.rst(rst),
.heartbeat_o(heartbeat_s)
);

assign LED[7] = heartbeat_s;
assign LED[6] = FIT1_Toggle_s;
assign LED[5:0] = GPO3_s[5:0];
</syntaxhighlight>

==FPGA Implementierung ==
Am besten den FPGA mit den µB-MCS '''vor''' der Vorbereitung des SDK komplett implementieren und auf das Board laden. Es müßen die LED's 7 und 8 mit jeweils eigene Frequenz blinken. Wenn nicht, dann ist bei der Generierung und Instanziierung des Cores ein Fehler unterlaufen.

Jetzt, falls noch nicht geöffnet, ein Tcl Fenster öffnen (''ISE:View->Panels->Tcl Console'') dann erscheint unten eine schmale Zeile in der Tcl Kommandos eingegeben werden können, die Ausgabe erscheint in dem Fenster darüber.

Jetzt das vom ''coregen'' erzeugte tcl Script starten: ''source ../core/microblaze_mcs_setup.tcl'' . Dieses script fügt eine Option für das tool ''ngdbuild'' (Process "''Translate''") bei der Implementierung
hinzu. Zur Überprüfung die Optionen anzeigen lassen mit Mausklick rechts auf "''Translate''" im Process-Fenster und "process properties" auswählen. Es findet sich jetzt in der Zeile "Other ... options" ein Eintrag beginnend mit "-bm" der auf eine ebenfalls von coregen erzeugtes *.bmm Datei zeigt.

[[Datei:Ss after setup tcl.png|thumb|center|400px|Tcl-Console]]

Diese Datei am besten in einem Texteditor öffnen. wichtig ist hier der Pfad zu den RAM-Blöcken die das binary für den Softcore speichern werden.
Der Teil ganz links ist der in ersten ''CoreGen''-Fenster angegebene Instanz-name. Der muss auch mit dem Instanznamen im Top-file übereinstimmen, sonst
bricht Translate ab. Entfernt man die grad erwähnte -bm Option wieder aus den "Process Properties" läuft zwar der Schritt Translate und alle Folgenden
durch, aber es wird Probleme bei "Vereinigung von Programm-binarie und FPGA bitfile" geben -> die FPGA logic wird zwar funktionieren, aber es wird kein Programm
auf dem Softcore laufen.

=Generierung Compilerumgebung und microblaze-programm=
Für die folgenden Schritte ist das Software development Kit (SDK) zu starten,
das findet sich im Ordner EDK (Embedded Development Kit):

[[Datei:Ss programmmenu sdk.png|thumb|center|400px|Startmenu mit Xilinx-tools]]

Das SDK fragt beim Start nach einem Verzeichniss für den workspace.

Dannach erscheint beim ersten Start ein Welcome-Screen. Diesen an besten wegklicken da er
das fenster "project explorer" überdeckt. Jetzt müßen wir nacheinander 3 verschieden "typen" von "projekten" anlegen:
*Hardware Platform spezification - eine beschreibung des systems aus microblaze, Programmspeicher und Peripherie.
Diese benötigt die Infos aus dem Coregenlauf
*board support package - Header-dateien, linkerskripte mit kosntanten/ addressbereichen etc. passend zum mikrocontrollersystem
*C/C++projekt die leere C-datei für das eigentliche Programm

[[Datei:Sdk project wizards.png|thumb|center|400px|New -> Projects]]

==Hardware Platform Specification==
File -> new -> project -> Xilinx -> Hardware Platform Specification

Der Projectname erscheint dann im project explorer. Der Autor wählte zur besseren Unterscheidbarkeit
zu den anderen Projekttypen den suffix _hwp. in der Spalte hardwareproject-file ist das file aus den Coregen-lauf
anzugeben, es findet sich daher in dem Verzeichniss Core.

==Erstellung Hardware project==
[[Datei:Ss hardware palltform settings.png|400px|thumb|center]]
==Erstellung Board support package==
==Erstellung Programm==
[[Datei:Ss sdk cproject settings.png|400px|thumb|center]]
<syntaxhighlight lang="C">
#include <xparameters.h>
#include <xiomodule.h>
#include <stdbool.h>

#define LED_DELAY 100000

int main()
{
//instantiate IOs
XIOModule GPIO;

volatile u32 i = 0;

//initialize IOs
XIOModule_Initialize(&GPIO, XPAR_IOMODULE_0_DEVICE_ID);
XIOModule_Start(&GPIO);

//LED
bool led_on = false;
int run = 1;

for (;;)
{
if (led_on) {XIOModule_DiscreteWrite(&GPIO, 3,run);
if (run == 0x20) run = 1; else run *= 2;}
led_on = !led_on;
for(i=0;i < LED_DELAY; ++i);
}
}
</syntaxhighlight>

==Zusammenfügen FPGA bitstream und Executable zur downladbaren Datei==
Im Menu "Xilinx Tools" den Punkt "Programm FPGA" auswählen und anschließend das (beim CoreGen) angelegte *.bmm file, das compilierte Programm (*.elf) und das *.bit File des in der ISE generierten FPGA's auswählen und den button "Program" drücken.
Jetzt wird mittels der Information über die genutztem BRAM-Blöcke aus der *.bmm-Datei im *.bit-File die Bereiche die die Initdaten für die BRAM-Speicherblöcke enthält mit dem Binary des Programms ausgetauscht und anschließend das FPGA programmiert.

=Fehlersuche=
Wenn möglich auch die beiden Zwischenergebnisse ("Gesamtdesign ohne MCS-Core instanziierung" und "Mit Core aber ohne Programm" am Board testen. Nur so lassen sich Fehler auf die Schritte im workflow zurückführen.

Bei Änderungen am Core versagt gelegentlich das automatische Update von BPS etc.. Deshalb bei Coreänderungen die obsoleten Projekte (Hardware project, BSP und C-projekt) löschen und den workflow ab Schritt "tcl.script" wiederholen.

Fehlermeldungen in die Eingabemaske von google kopieren und nach Antworten bei Xilinx oder Internetforen suchen. Das führt bei den
oft verwirrenden Fehlermeldungen schnell zum Erfolg. So weist diese Meldung über Memory leaks:
[[Datei:Ss more ngdbuilt error.png|400px|thumb|center|ngdbuil error]]
eigentlich darauf hin, das der Instanzname des MCS-cores nicht stimmt. Der "Answer record" bei Xilinx http://www.xilinx.com/support/answers/51538.html erklärt wie man den korrekten Namen findet und in das BMM-file einträgt.

= Literatur =
* http://ece.wpi.edu/~rjduck/Microblaze%20MCS%20Tutorial%20v5.pdf - Eine in Englisch verfasste Anleitung zum Durchklicken.
Als Beispiel wird eine microblaze basierte UART-Verbindung zwischen PC und Nexsys2/3 board implementiert, verwendet wird die ISE 14.5.
* http://jimselectronicsblog.blogspot.de/2014/03/implementing-microblaze-mcs-on-papilio.html
Eine Englischsprachige Klickanleitung für das papilio-One board. Hier wird auch gezeigt wie UCF und top entity
mit dem PlanAHead tool angelegt wird. Die Screenshost sind recht gut kommentiert.
* http://www.xilinx.com/support/documentation/sw_manuals/xilinx13_4/ds865_microblaze_mcs.pdf - XILINX DS865, die offizielle Beschreibung des Cores
* http://www.xilinx.com/support/documentation/sw_manuals/xilinx2013_3/pg116-microblaze-mcs.pdf - XILINX PG116, die offizielle Anleitung für Vivado
*http://www.xilinx.com/support/documentation/sw_manuals_j/xilinx14_5/pg048-microblaze-mcs.pdf - Xilinx PG048, die offizielle Anleitung für Vivado

ARM Cortex Mikrocontroller

2015-02-03T11:01:54Z

217.86.180.189: /* CMSIS - ARM Cortex Software Libraries */ Satz entschwurbelt

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 nur um die ARM Cortex-M Mikrocontroller, nicht jedoch um ARM [[Cortex-A]] Prozessoren, welche in Smartphones 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!
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.energymicro.com/products/efm32-zero-gecko-microcontroller-family EFM32 Zero Gecko] von [http://www.energymicro.com Silicon Labs (ehemals Energy Micro)], 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]

== 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.energymicro.com/products/efm32-tiny-gecko-microcontroller-family EFM32 Tiny Gecko], [http://www.energymicro.com/products/efm32-gecko-microcontroller-family EFM32 Gecko] sowie [http://www.energymicro.com/products/efm32-leopard-gecko-microcontroller-family EFM32 Leopard Gecko] von [http://www.energymicro.com Silicon Labs (ehemals Energy Micro)] , 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)
* [https://www.silabs.com/products/mcu/Pages/ARM-32bit-microcontroller.aspx SiM3U1xx] von Silabs
* [http://www.holtek.com.tw/english/products/32bit_flashmcu.htm HT32] von Holtek Semiconductor

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.energymicro.com/products/efm32-wonder-gecko-microcontroller-family EFM32-Wonder Gecko] von [http://www.energymicro.com Silicon Labs (ehemals Energy Micro)], 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 single 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.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.coocox.org/CooCox_CoIDE.htm CooCox IDE] (Eclipse basierend)
* [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.emide.org/ emIDE] Windows, komplette Visual Studio artige Entwicklungsumgebung (basierend auf Code::Blocks) mit GCC und Debugger (Unterstützung für Adapter von Segger) 
* [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 <u>GCC ohne Codesize Limit</u> 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]'''
* '''NXP''' bietet für seine '''LPC''' Prozessorfamilien eine <u>kostenlose</u> 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.

Kommerzielle Entwicklungsumgebungen (zum Teil kostenlos mit Einschränkungen) für ARM-basierte Mikrocontroller sind z. B.:
* [http://rowley.co.uk/arm/ Crossworks ARM] (GCC-basiert, Windows, Mac OS und Linux)
* [http://www.cosmicsoftware.com/download_cortex_64k.php Cosmic Software] (Windows), bis 64kB kostenlos
* [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://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 ===
* Lua: http://www.eluaproject.net/
* Forth: https://github.com/ekoeppen/CoreForth
* JavaScript: http://www.espruino.com/

=== 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. 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.energymicro.com Energy Micro], XMC1100 von 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]]. Viele Entwicklungsboards enthalten auch einen On-Board-Debugadapter zum direkten Anschluss an USB, so dass kein externer SWD- oder JTAG-Adapter notwendig ist.

=== 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 Entwicklungskits (ca. 20€), mit integriertem ST-Link (Debugger). Zum Beispiel das [http://www.st.com/stm32f4-discovery STM32F4 Discovery Board].

Von Energymicro gibt es [http://www.energymicro.com/tools/efm32-starter-kits Starter Kits] mit integriertem J-Link (Debugger) ab ca. 50 € z.B. das [http://www.energymicro.com/tools/efm32-tiny-gecko-starter-kit EFM32 Tiny Gecko Starter Kit] bei [http://de.mouser.com/ProductDetail/Energy-Micro/EFM32-TG-STK3300/?Energy-Micro/EFM32-TG-STK3300/&qs=sGAEpiMZZMvFPGEOwQcrYyZeaSbmjQvRx7NKUweLQtQ= 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.

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://www.mkp.com/companions/defaultindividual.asp?isbn=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| ]]