Mikrocontroller.net - Benutzerbeiträge [de]

FAQ

2010-11-08T12:57:19Z

80.72.130.218: /* Funktionszeigertabellen */

Ein Verzeichnis von im Forum oft gestellten und immer wieder beantworteten Fragen und den zugehörigen Antworten:

=Wie kann ich Zahlen auf [[LCD]]/[[UART]] ausgeben?=

Aber die Bibliothek, die du benutzt, stellt nur eine Funktion zur Verfügung, mit der man einen String ausgeben kann... Was tun?

In den folgenden Beispielen wird eine selbstgeschriebene Funktion zur Stringausgabe auf LCD - die Funktion lcd_string() - aus dem [[AVR-GCC-Tutorial/LCD-Ansteuerung|LCD-Teil des AVR-GCC-Tutorials]] verwendet:

<c>
lcd_string( "Hallo Welt" ); // ggf. auch lcd_out() o.ä. in anderen Libraries
</c>

Um also eine Zahl (numerische Konstante oder Variableninhalt) auszugeben, muss von dieser Zahl zunächst ihre String-Repräsentation ermittelt werden. Hier geht es aber nur darum, zu zeigen wie man diese String Repräsenation erzeugen kann. Was man dann mit diesem String weiter macht, ob das dann eine LCD-Ausgabe oder eine UART-Übertragung oder das Abspeichern auf SD-Karte oder ... ist, spielt eine untergeordnete Rolle.

Es gibt mehrere Möglichkeiten, sich die Stringrepräsentation zu erzeugen:

===itoa()===

itoa() ist keine C-Standardfunktion (wohl aber ihre Umkehrung atoi() ). Auf manchen Compilern heisst diese Funktion dann folgerichtig _itoa(), wobei der führende _ eben anzeigt, dass es sich um eine Erweiterung des C-Standards handelt. Bei [[WinAVR]] ist itoa() Bestandteil der mitgelieferten Library avr-libc, in der Libary [http://www.nongnu.org/avr-libc/user-manual/group__avr__stdlib.html''stdlib.h''].

<c>
#include <stdlib.h>
char Buffer[20];
int i = 25;

itoa( i, Buffer, 10 );
lcd_string( Buffer ); // ggf. auch lcd_out() o.ä. in anderen Libraries
</c>

itoa( i, Buffer, 10 ); - Die Zahl i wird nach ASCII gewandelt und die String Repräsentierung davon wird in Buffer abgelegt. Die Basis, in der diese Wandlung erfolgt, ist das 10-er System. Wird das dritte Argument von 10 in zb. 2 oder auch 16 abgewandelt, erhält man die binäre oder eben eine hexadezimale Repräsentierung des Wertes. Auch wenn 10, 2 und 16 die häufigsten Angaben an dieser Stelle sind, kann itoa aber grundsätzlich in jedes beliebige Zahlensystem wandlen.

Wichtig ist, darauf zu achten, dass das Array Buffer groß genug dimensioniert wird, um alle Zeichen der Textrepräsentation der Zahl aufzunehmen - inklusive der 0, die den String abschließt, sowie ein mögliches Vorzeichen.

Anzumerken bleibt weiter, dass es normalerweise für alle Datentypen entsprechende Umwandlungsfunktionen gibt, wenn es sie für einen Datentyp gibt. Die Namensgebung lehnt sich an das Schema an: ''Kürzel_für_den_Datentyp to a''. Eine Funktion die einen unsigned int wandelt, heißt dann utoa (oder _utoa), Floating Point heißt dann ftoa (oder _ftoa), etc.

===sprintf()===

<c>
char Buffer[20];
int i = 25;

sprintf( Buffer, "%d", i );
lcd_string( Buffer ); // ggf. auch lcd_out() o.ä. in anderen Libraries
</c>

Diese Methode funktioniert auch bei long oder float Werten. Unbedingt beachtet werden muss allerdings, dass die Typkennzeichnungen im sog. Format-String (hier "%d") mit den tatsächlichen Typen der auszugebenden Werten übereinstimmt. Und dass der Buffer, der den Text aufnimmt, auch groß genug dimensioniert wird. Dabei sollte die 0, die den String terminiert, nicht vergessen werden.

Mit sprintf() hat man dieselben Möglichkeiten zur Formatierung wie bei printf() (siehe unten). Insbesondere gibt es natürlich die Möglichkeit die Zahl gleich in einen umgebenden Text einzubetten bzw. Formatierungen anzugeben:

<c>
char Buffer[20];
int i = 25;

sprintf( Buffer, "Anzahl: %d Stueck", i );
lcd_out( Buffer );
</c>

Der "Haken" an der mächtigen Funktion sprintf() ist, daß sie auch bei minimalisierter Konfiguration verhältnismäßig viel Programmspeicher (Flash-ROM) belegt und relativ viel Prozesszeit benötigt. Daher sollte man sprintf() nur verwenden, wenn kein Speicher- und Prozesszeitmangel besteht. Sonst sollte itoa() oder eine eigene, auf die Bedürfnisse optimierte Implementierung auf jeden Fall vorgezogen werden.

====Formatierungen mit printf====

Für jedes auszugebende Argument muss es im Formatstring einen entsprechenden Formatbezeichner geben. Der Aufbau eines Formatbezeichners ist immer

%[Modifizierer][Feldbreite][.Präzision]Typ

Typ ist dabei eine Kennung, der mit dem Datentyp des jeweiligen auszugebenden Argumentes übereinstimmen muss. Einige oft benutzte Kennungen, ohne Anspruch auf Vollständigkeit, sind:
c char
d int
f float, double
ld long
u unsigned int
lu unsigned long
p pointer
s string
x ein int wird ausgegeben, die Ausgabe erfolgt aber als Hexadezimalzahl
X ein int wird ausgegeben, die Ausgabe erfolgt aber als Hexadezimalzahl, wobei Grossbuchstaben verwendet werden.

Die Feldbreite gibt die Breite des Ausgabefeldes an, in die die Ausgabe durchgeführt werden soll. Reicht die angegebene Feldbreite nicht aus, so vergrößert printf diese Breite eigenmächtig. Die Feldbreite muß nicht angegeben werden. In diesem Fall bestimmt printf selbst die Feldbreite, so dass die Ausgabe darin Platz findet. Mit der Feldbreite hat man eine simple Möglichkeit dafür zu sorgen, dass der erzeugte String immer eine konstante Länge hat, selbst wenn die auszugebende Zahl diese Länge gar nicht benötigen würde (wichtig zb. bei Tabellen).

Der Modifizierer bestimmt, wie und womit nicht benutzte Felder des Ausgabefeldes gefüllt werden sollen, wie die Ausrichtung innerhalb des Feldes erfolgen soll und ob ein Vorzeichen auch dann ausgegeben werden soll wenn die auszugebende Zahl positiv ist. Wird kein Modifizierer angegeben, so werden nicht benutzte Felder mit einem Leerzeichen gefüllt, positive Vorzeichen unterdrückt und die Ausgabe im Feld rechts ausgerichtet.

+ Vorzeichen wird immer ausgegeben
- Die Ausgabe wird im Ausgabefeld linksbündig ausgerichtet
0 anstelle von Leerzeichen werden führende 0-en ausgegeben

Die Präzision kommt nur bei float oder double Zahlen zum Einsatz. Sie legt fest, wieviele Positionen der kompletten Feldbreite für die Ausgabe von Nachkommastellen reserviert werden sollen. Auch sie muss wiederrum nicht angegeben werden und printf benutzt in so einem Fall Standardvorgaben.

===== Beispiele =====
* "%d" Ausgabe eines Integer
* "%5d" Ausgabe eines Integer in einem Feld mit 5 Zeichen Breite
* "%05d" Ausgabe eines Integer in einem Feld mit 5 Zeichen Breite, wobei das Feld links mit führenden Nullen auf 5 Zeichen aufgefüllt wird
* "%-5d" Ausgabe eines Integer in einem Feld mit 5 Zeichen Breite. Die Zahl wird linksbündig in das Feld gestellt.
* "%6.3f" Ausgabe eines float (oder double). DIe Ausgabe erfolgt in einem Feld mit 6 Zeichen Breite, wobei 3 Nachkommastellen ausgegeben werden. Achtung: In der Feldbreite ist auch ein eventuelles Vorzeichen sowie der Dezimalpunkt enthalten. Bei einer Feldbreite von 6 Zeichen und 3 Nachkommastellen, bleiben bei einer positiven Zahl daher nur 2 Positionen für den Vorkommaanteil, bei negativen sogar nur 1 Stelle ( 6 - 3 Nachkommastellen - 1 Dezimalpunkt - 1 Vorzeichen == 1 )

===Eigene Umwandlungsfunktionen===

Möchte man itoa() nicht benutzen oder hat es gar auf seinem System nicht zur Verfügung, dann ist es auch nicht schwer, sich selbst eine Funktion dafür zu schreiben:

<c>
void ItoA( int z, char* Buffer )
{
int i = 0;
int j;
char tmp;
unsigned u; // In u bearbeiten wir den Absolutbetrag von z.

// ist die Zahl negativ?
// gleich mal ein - hinterlassen und die Zahl positiv machen
if( z < 0 ) {
Buffer[0] = '-';
Buffer++;
// -INT_MIN ist idR. größer als INT_MAX und nicht mehr
// als int darstellbar! Man muss daher bei der Bildung
// des Absolutbetrages aufpassen.
u = ( (unsigned)-(z+1) ) + 1;
}
else {
u = (unsigned)z;
}
// die einzelnen Stellen der Zahl berechnen
do {
Buffer[i++] = '0' + u % 10;
u /= 10;
} while( u > 0 );

// den String in sich spiegeln
for( j = 0; j 

Das Grundprinzip ist einfach: 
Die Ermittlung der einzelnen Stellen erfolgt in der zentralen Schleife

<c>
do {
Buffer[i++] = '0' + u % 10;
u /= 10;
} while( u > 0 );
</c>

durch fortgesetzte Division durch 10 und Restbildung.

8392

8392 % 10 -> 2
8392 / 10 -> 839

839 % 10 -> 9
839 / 10 -> 83

83 % 10 -> 3
83 / 10 -> 8

8 % 10 -> 8
8 / 10 -> 0

Nur leider erhält man dadurch die einzelnen Ziffern der Zahl in umgekehrter Reihenfolge im String ('2' '9' '3' '8' anstelle von '8' '3' '9' '2'). Dies ist aber kein Problem, die nachfolgende Schleife

<c>
for( j = 0; j 

spiegelt den String in sich, sodass danach der String eine korrekte Repräsentation der ursprünglichen Zahl darstellt. Der Funktionsteil vor der 'Zerlegeschleife' behandelt den Sonderfall daß die Zahl negativ ist. Negative Zahlen werden behandelt indem im Endergebnis ein '-' vermerkt wird und danach die Zahl positiv gemacht wird.

Siehe auch:
* Forenbeitrag [http://www.mikrocontroller.net/topic/67405#541885 Integer-Zahl in String mit bestimmter Zeichenlänge]
* Forenbeitrag [http://www.mikrocontroller.net/topic/84005#704736 (Resourcenschonend) Wert einer Variable am LCD ausgeben] von Niels Hüsken
* [[Festkommaarithmetik]]

=Datentypen in Operationen=
Ein häufiges Problem betrifft die Auswertung von Ausdrücken. Konkret die Frage nach den beteiligten Datentypen.
zb
<c>
double i;
int j, k;

i = j / k;
</c>
Die Frage lautet dann: Warum erhalte ich keine Kommastellen, ich weise doch das Ergebnis einem double zu?

Dazu ist zu sagen, dass C nicht so funktioniert. Die Tatsache dass i eine double Variable ist, ist für die Auswahl der Operation, welche die Division durchführt, völlig irrelevant. C orientiert sich ausschliesslich an den
Datentypen der beteiligten Operanden, um zu entscheiden ob die Division als Integer- oder als Gleitkommadivision durchzuführen ist. Und da sowohl j als auch k ein Integer sind, wird die Division als Integerdivision durchgeführt
unabhängig davon, was mit dem Ergebnis weiter passiert. Erst nach der Division wird das Ergebnis in einen double überführt, um es an i zuweisen zu können. Zu diesem Zeitpunkt gibt es aber keine Kommastellen mehr, eine Integerdivision erzeugt keine. Und damit tauchen klarerweise auch im Ergebnis keine auf.

Aus genau diesem Grund ist zb das Ergebnis von
<c>
double i;
i = 5 / 8;
</c>
eine glatte 0 und nicht 0.625. Die Division 5 / 8 wird als Integer Division gemacht und liefert als solche keine Nachkommastellen. Wird das Ergebnis der Division in einen double umgewandelt, um es an i zuweisen zu können, ist das Kind schon in den Brunnen gefallen: Die Nachkommastellen sind schon längst weg bzw. waren nie vorhanden.

Will man den Compiler dazu zwingen, die Division als Gleitkommadivision durchzuführen, so muss man daher dafür sorgen, dass mindestens einer der beteiligten Operanden ein double Wert ist. Dann bleibt dem Compiler nichts anderes übrig, als auch den zweiten Operanden ebenfalls zu einem double zu machen und die Operation als Gleitkommaoperation durchzuführen.

<c>
double i;
i = 5.0 / 8.0;

i = (double)j / k;
</c>

Generell implementiert der Compiler eine Operation immer im 'höchsten' Datentyp, der in einer Operation vorkommt. Operanden in einem 'niedrigeren' Datentyp werden automatisch immer in diesen 'höchsten' Datentyp umgewandelt, zumindest aber int. Die Reihung orientiert sich dabei an der Regel: Ein 'höherer' Datentyp kann alle Werte eines 'niedrigeren' Datentyps aufnehmen.

int
unsigned int
long
unsigned long
long long
unsigned long long
double

float kommt in dieser Tabelle gar nicht vor, da Gleitkommaoperationen grundsätzlich immer als double-Operationen durchgeführt werden. Wohl kann es aber sein, dass double und float dieselbe Anzahl an Bits benutzen. Damit reduziert sich eine double Operation effektiv auf eine float Operation.

Hat man also in einer Operation 2 Operanden der Datentypen int und long, so wird der int implizit zu einem long gemacht und die Operation als long Operation durchgeführt. Das Ergebnis hat dann den Datentyp long.

==Welche Datentypen haben Konstante?==

Auch Zahlenkonstante besitzen einen Datentyp, der selbstverständlich vom Compiler bei der Auswahl der Operation berücksichtigt wird. Hier gilt die Regel: Benutzt wird der Datentyp, der die Zahl gerade noch aufnehmen kann. Eine Zahlenkonstante 5 hat daher den Datentyp int. Die Zahl 32767 passt gerade noch in einen int, und hat daher den Datentyp int. 32768 ist für einen int bereits zu groß und hat daher den Datentyp long. 5.0 ist hingegem immer eine double-Konstante. Der Dezimalpunkt erzwingt dieses.

Eine kleine Feinheit gibt es noch zu beachten. Konstanten in dezimaler Schreibweise haben immer einen signed Datentyp, während Konstante in hexadezimaler bzw. oktaler Schreibweise immer einen unsigned Datentyp haben.

Möchte man einer Konstanten einen bestimmten Datentyp aufzwingen, so gibt es dazu 2 (ein halb) Möglichkeiten:
* Entweder man castet die Konstante in den gewünschten Datentyp
<c>
(long)5
</c>
* oder man benutzt die in C dafür vorgesehene Schreibweise, indem man der Konstanten einen Suffix anhängt, der den gewünschten Datentyp beschreibt
<c>
5L
</c>
Beides ergibt eine dezimale 5, die vom Datentyp long ist.

* eine Zahl in mit einem Dezimalkomma
<c>
5.0
</c>
ist immer eine double Zahl. Es sei denn sie hat explizit eien Suffix
<c>
5.0F
</c>
dann hat man es mit einer float Zahl zu tun.

Die gültigen Suffixe für Zahlen sind U, L, UL und F:

* U wie unsigned; dabei wird zuerst int angenommen. Es erfolgt eine automatische Ausweitung auf long, wenn die Zahl den Wertebereich eines unsigned int überschreitet.
* L wie long; die Zahl selbst kann int oder double sein.
* UL wie unsigned long. Eigentlich eine Zusammensetzung aus U und L
* F wie float.

=Aktivieren der Floating Point Version von sprintf beim WinAVR mit AVR-Studio=
Beim WinAVR/AVR-Studio wird standardmässig eine Version der printf-Bibliothek verwendet, die keine Floating Point Verarbeitung unterstützt. Die meisten Programme benötigen keine Floating Point Unterstützung, sodass hier wertvoller Programmspeicherplatz gespart werden kann.

Benutzt man dann allerdings eine printf Variante für die Ausgabe von Floating Point Zahlen, so erscheint an Stelle der korrekt formatierten Zahl lediglich ein '?'. Dies ist ein Indiz, dass die Floating Point Verarbeitung im Projekt aktiviert werden muss.

Um die Floating Point Verarbeitung zu aktivieren, geht man im AVR-Studio wie folgt vor:
Menüpunkt: "Project"/"Configuration Options"

Im sich öffnenden Dialog wird in der linken Navigationsleiste der Eintrag "Libraries" ausgewählt.
Unter 'Available Link Objects' werden alle möglichen Bibliotheken angeboten. Für die Aktivierung der Floating Point Unterstützung sind 2 interessant:
* libprintf_flt.a
* libm.a
Beide Bibliotheken werden durch aktivieren und einen Druck auf "Add Library -->" in die rechte Spalte übernommen.

libc.a sollte übrigens nicht zu den Bibliotheken hinzugefügt werden da sie automatisch eingebunden wird. Etwas Hintergrundinformationen gibt es in [http://www.mikrocontroller.net/topic/173630 diesem Thread.]

[[Bild:AVR_Studio_float1.gif]]

Danach wählt man in der Navigationsleiste den Eintrag "Custom Options". Unter 'Custom Compilation Options' wird '[Linker Options]' ausgewählt und in das Textfeld rechts/unten wird der Text
-Wl,-u,vfprintf
eingegeben. Ein Druck auf "Add" befördert die Zeile in das Listenfeld darüber, welches die Kommandos an den Linker enthält.

[[Bild:AVR_Studio_float2.gif]]

Damit ist die Konfiguration abgeschlossen, "OK"

=Wie funktioniert String-Verarbeitung in C?=

In C gibt es, anders als in anderen Programmiersprachen, keinen eigenen String-Datentyp. Als Ersatz dafür werden Character-Arrays benutzt, in denen die einzelnen Character (=Zeichen) gespeichert werden. Allerdings gibt es noch einen Zusatz: Das letzte Zeichen eines Strings ist immer ein '\0'-Zeichen, dass das Ende des Strings markiert. Schlieslich kann ja das Array wesentlich größer sein, als der in ihm gespeicherte String und irgendwie müssen ja diverse Funktionen das tatsächliche Ende eines Strings erkennen können.

Möchte man also die Zeichenkette "Hello World" in einem String speichern, so wird dafür ein Array mit mindestens der Länge 12 benötigt. 11 für die Zeichen die "Hello World" bilden, plus eine zusätzliche Position für das abschliesende '\0'-Zeichen.

Da Strings in char-Arrays gespeichert werden, können selbstverständlich normale Array Operationen dafür benutzt werden:

<c>
char Test[12];

Test[0] = 'H';
Test[1] = 'e';
Test[2] = 'l';
Test[3] = 'l';
Test[4] = 'o';
Test[5] = ' ';
Test[6] = 'W';
Test[7] = 'o';
Test[8] = 'r';
Test[9] = 'l';
Test[10] = 'd';
Test[11] = '\0'; // das abschliessende \0 nicht vergessen! Sonst ist
// das kein String!

char Temp[6];

for( i = 0; i < 6; ++i )
Temp[i] = Test[ i + 6 ];
</c>

'''Hinweis:''' Das ''''\0'''' ist nichts anderes als eine binäre Null. Diese spezielle Schreibweise soll explizit die Verwendung dieser ''0'' als Stringende - Character ''(char)0'' hervorheben.

Wird im C-Quelltext ein String in der Form "Hello World" geschrieben, also nicht als einzelne Zeichen, so muss man sich um das abschliessende '\0' Zeichen nicht kümmern. Der Compiler ergänzt das stillschweigend von selbst.

== Einige Stringfunktionen ==
Arrays sind in C keine vollwertigen Datentypen, z. B. ist es nicht möglich einem Array in einem Rutsch ein anderes Array zuzuweisen oder 2 Arrays miteinander zu vergleichen. Genau das möchte man aber in der Stringverarbeitung häufig, sodass es dafür Standardfunktionen gibt, die allesamt im Headerfile "string.h" zusammengefasst sind und deren Namen alle mit str... beginnen. Allen diesen Funktionen gemeinsam ist, dass sie sich nicht um die korrekte Bereitstellung von Arrays kümmern, sondern davon ausgehen, dass dies vom Programmierer korrekt erledigt wird.

=== strcpy( char* dest, const char* src ) ===
Kopieren eines Strings von der Speicherfläche auf die src zeigt, zur Speicherfläche, auf die dest zeigt.
<c>
char Ziel1[20];
char Ziel2[20];

strcpy( Ziel1, "Hallo Welt" );
strcpy( Ziel2, Ziel1 );
</c>

=== strcat( char* dest, const char* src ) ===
Anhängen eines Strings an einen bestehenden String.
<c>
char Ziel[20];
char Temp[20];

strcpy( Ziel, "Hallo " ); // Ziel enthält jetzt den String "Hallo "
strcat( Ziel, "Welt" ); // Ziel enthält jetzt den String "Hallo Welt"

strcpy( Temp, " !" );
strcat( Ziel, Temp ); // Ziel enthält jetzt den String "Hallo Welt !"
</c>

=== strcmp( const char* str1, const char* str2 ) ===
Vergleichen 2-er Strings. Das Ergebnis ist 0, wenn die beiden Strings identisch sind.

<c>
char Ziel[20];

strcpy( Ziel, "Hallo Welt" ); // Ziel enthält jetzt den String "Hallo Welt"

if( strcmp( Ziel, "Hallo Welt" ) == 0 )
printf( "Ziel war 'Hallo Welt'\n" );

if( strcmp( Ziel, "test" ) != 0 )
printf( "Ziel war NICHT 'test'\n" );
</c>

=== strlen( const char* str ) ===
Die Länge eines Strings feststellen. Die Länge beinhaltet nicht das abschliessende '\0' Zeichen.

Unter 'Länge' wird hier die tatsächliche Länge des Strings (also die Anzahl der im String gespeicherten Zeichen) verstanden und nicht die 'Länge' des Arrays in dem der String gespeichert ist. Wird der Text "test" in einem char-Array der Größe 20 gespeichert, so lautet das Ergebnis von strlen() 4 und nicht etwa 20

<C>
char string[20];
strcpy( string, "test" );
i = strlen( string ); // i bekommt hier den Wert 4
</C>

== Beispiele ==

<c>
#include "string.h"

int main()
{
char Meldung[14];
strcpy( Meldung, "Hello World" );
}
</c>
Mittels der Definition
<c>
char Meldung[14];
</c>
wird ein Array bereitgestellt, welches maximal 14 Zeichen aufnehmen kann. Hello World verbraucht für die lesbaren Zeichen 11 Array-Positionen, dazu noch das obligatorische abschliessende '\0' Zeichen, macht in Summe 12 Positionen. Eine Definition von 14 Zeichen ist also mehr als minimal notwendig
wäre. Das macht aber nichts, da durch das abschliessende '\0' Zeichen immer feststellbar ist, an welcher Stelle der tatsächliche String zu Ende ist. Die restlichen 2 Array-Positionen sind zur Zeit halt einfach unbenutzt.
strcpy() kopiert den 2.ten angegebenen String an die Position auf die sein erstes Argument zeigt. Im obigen Beispiel zeigt das 1.te Argument auf den Beginn von Meldung, also auf das Array. Folgerichtig wird der String "Hello World" in das Array Meldung umkopiert. Man beachte auch, dass der Compiler den direkt angegebenen String "Hello World" automatisch mit einem '\0' Zeichen ergänzt hat.
Nach Ausführung der strcpy() Funktion enthält also Meldung den Inhalt:

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | | W | o | r | l | d | \0| | |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Möchte man an diesen Text jetzt noch etwas anfügen, z. B. ein "?", so würde das so aussehen:

<c>
#include "string.h"

int main()
{
char Meldung[14];
strcpy( Meldung, "Hello World" );
strcat( Meldung, "?" );
}
</c>


Man beachte: auch wenn hier scheinbar nur ein einzelnes Zeichen angehängt wird, so handelt es sich doch um einen String. Strings werden in C immer mit einem " eingeleitet und abgeschlossen. Im Gegensatz zu einzelnen Zeichen, die in einfache ' eingefasst werden. "?" ist also nicht dasselbe wie '?'! Das
erste ist ein String (der mit dem obligatorischen '\0' Zeichen insgesamt aus 2 Zeichen besteht), während letzteres ein einzelnes Zeichen darstellt! Die meisten str... Funktionen arbeiten nur mit Strings!


Da Meldung maximal 14 Zeichen umfassen kann, der Text "Hello World?" aber nur aus 13 Zeichen besteht, funktioniert Obiges auch ohne Probleme. Der Array-Inhalt sieht dann wie folgt aus:

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | | W | o | r | l | d | ? | \0| |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Ein schwerwiegender Fehler wäre es, wenn der komplette String nach dem strcat() aus mehr als 14 Zeichen (das '\0'-Zeichen nicht vergessen!) bestehen würde.

<c>
#include "string.h"

int main()
{
char Meldung[14];
strcpy( Meldung, "Hello World" );
strcat( Meldung, " von mir" );
}
</c>

würde also das Array überlaufen lassen.

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
| H | e | l | l | o | | W | o | r | l | d | | v | o | n m i r \0
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+

Man sieht sehr schön, daß in diesem Fall die weiteren Zeichen einfach an die Folgepositionen im Speicher geschrieben werden und dadurch ungewollt Speicher verändern, der nicht zu Meldung gehört. Abhängig von den Details des Programmes können aber an dieser Stelle im Speicher z. B. ganz andere Variablen liegen, die dann verändert werden. strcpy(), strcat() oder alle anderen String-Funktionen können den Programmierer gegen diesen Fall nicht schützen! Dazu müssten sie die Größe des Speicherbereichs kennen, was sie nicht tun. Es obliegt einzig und alleine der Sorgfalt des Programmierers, das Programm gegen solche Fälle abzusichern!

Seit einiger Zeit wurde das Sammelsurium der str... Funktionen durch Varianten ergänzt, die sich anschicken dieses Manko zu entschärfen. Diesen Funktionen wird die maximale Anzahl der zu bearbeitenden Zeichen mitgegeben. Mit der Kenntnis der Größe des Zielbereichs und der Länge des bereits darin enthaltenen Strings ist es damit möglich eine Obergrenze auszurechnen, wieviele Zeichen von einer Funktion gefahrlos bearbeitet werden dürfen, ehe der Zielbereich überlaufen würde.

Diese Funktionen heißen grundsätzlich gleich wie die str... Funktionen, nur befindet sich ein kleines 'n' im Funktionsnamen. Aus strcpy wird so strncpy, aus strcat wird strncat usw. Für Details dazu sei auf Literatur oder Web-Recherche verwiesen. Auch wenn einen diese Funktionen gegen die gefürchteten Array-Overflows schützen können, so muß man sich trotzem klarmachen, daß dieser Schutz nur die halbe Miete ist. Denn was soll strncpy denn tun, wenn der zu kopierende String nicht in das Zielarray passt? strncpy kopiert soviel wie es kann und gibt dann auf. Aber: Dadurch ist der String aber nicht zur Gänze in den Zielbereich kopiert worden. Programmteile die darauf angewiesen sind, daß der String vollständig kopiert wurde, werden dann nicht mehr oder nicht richtig funktionieren usw. Auch wenn die strn... Funktionen eine gewisse Abhilfe bringen und zumindest den Absturz eines Programmes verhindern können, stellen sie dennoch keine Allheilmittel dar. Um die korrekte Abschätzung der benötigten Arraygrößen kommt man nicht umhin.

strlen() liefert die Länge eines Strings. Die Längenangabe beinhaltet dabei nicht das abschliessende '\0' Zeichen:

<c>
#include "string.h"

int main()
{
char Meldung[14];
int Len;

strcpy( Meldung, "Hello World" );
Len = strlen( Meldung );

/* Hier enthaelt Len den Wert 11 */

Len = strlen( "Hallo Welt" );

/* Hier enthält Len den Wert 10 */
}
</c>

strcmp() schlussendlich vergleicht 2 Strings auf Gleichheit. Der Rückgabewert spiegelt dabei die Position des ersten Unterschiedes in den beiden Strings wieder. Folgerichtig sagt ein Wert von 0 daher aus, dass die beiden Strings identisch sind:

<c>

#include "string.h"

int main()
{
char Meldung1[14];
char Meldung2[14];

strcpy( Meldung1, "Hello World" );
strcpy( Meldung2, "Hallo Welt" );

if( strcmp( Meldung1, Meldung2 ) == 0 ) {
/* die Strings sind identisch */
}
else {
/* die Strings sind nicht identisch */
}

if( strcmp( Meldung2, "Hallo Welt" ) == 0 ) {
/* Meldung2 war "Hallo Welt" */
}
}

</c>

Es gibt noch weitere String-Funktionen, dafür sei aber auf die Verwendung der zum Compiler gehörenden Dokumentation bzw. auf einführende Literatur zum Thema 'Programmieren in C' verwiesen.

== wie schreibt man eine Funktion, die einen String liefert? ==

will man eine Funktion schreiben, die einen String liefert, so hat man ein Problem. So gehts nicht:

<c>
char string[10];
c = uart_get_line();

...

char uart_get_line()
{
char string[10];
uint8_t i = 0;

for( ... )
{
...
string[i] = ...;
...
}
string[i] = '\0';
return *string;
}
</c>

Strings sind ja nichts anderes als Zeichen in einem Array und Arrays kann man nicht als Ganzes in C einfach so zuweisen. Das bedeutet aber auch, dass uart_get_line gar nicht ein Array als solches liefern kann! Daher hat auch der Programmierer versucht, sich mit einem char als Rückgabewert bzw. dem *string im return sich aus der Affäre zu ziehen. Nur: so funktioniert das nicht. uart_get_line würde hier nur ein einziges Zeichen zurückliefern und keinen String!

Eine naheliegende Lösung wäre:
<c>
// liest eine Zeile (maximal 9 Zeichen) und liefert sie als
// nullterminierten String zurück:
char * uart_get_line()
{
char string[10];
uint8_t i = 0;

for( ... )
{
...
string[i] = ...;
...
}
string[i] = '\0';
return string; // nicht *string
}
</c>

Das ist jetzt schon etwas besser, aber immer noch falsch.

Gebessert hat sich ja schon der Rückgabetyp; dazu passt das return
string statt return *string.

Mit *string würde man ja ein char liefern, und zwar das unterste in
string, mithin string[0].
Jetzt will ma ja aber nicht das eine Zeichen liefern, sondern den ganzen
String. Und das geschieht in C, indem man einen Zeiger auf das erste
Zeichen nimmt. Das ist string.

Falsch (und zwar richtig falsch!) ist diese Lösung aber aus folgendem Grund:
string ist eine automatische Variable (alle lokalen Variablen in einer
Funktion oder in einem Block sind automatisch, wenn nicht static davor
steht). Eine automatische Variable existiert aber nur, solange der umgebende
Block (hier die Funktion) abgearbeitet wird.
Sofort danach kann der Speicherplatz für etwas anderes genutzt werden,
meist für Parameter einer aufgerufenen Funktion, oder deren lokale
Variablen, oder Rücksprungadressen, temporäre Zwischenwerte oder was
auch immer.

Normalerweise ist das in Ordnung, weil man ja auf eine Variable mit
ihrem Namen nur zugreifen kann, solange man in demselben Block ist.

<c>
{
int i = 12;
i += 12;
}
printf( "%d", i ); // geht nicht
</c>

So etwas verhindert der Compiler aus gutem Grund: i ist eine Variable
in dem Block mit den geschweiften Klammern und existiert nur solange
der Block abgearbeitet wird.
Das printf() steht außerhalb, hier lässt der Compiler die Verwendung
von i nicht mehr zu - die Variable existiert dann auch gar nicht mehr.
Ändert man das etwas ab, hat man den Compiler überlistet:

<c>
int* zeiger_auf_i;
{
int i = 12;
i += 12;
zeiger_auf_i = &i;
}
...
printf( "%d", *zeiger_auf_i );
</c>

Jetzt macht man im Prinzp dasselbe wie eben, nur etwas umständlicher.
In zeiger_auf_i merkt man sich die Adresse von i, und im printf()
benutzt man die Adresse um auf i zuzugreifen.
Jetzt verhindert Compiler das nicht. Syntaktisch geht alles mit rechten Dingen zu. Es ist aber noch genauso falsch: wenn das printf() läuft, wird über
den Zeiger auf i zugegriffen, obwohl i gar nicht mehr existiert
bzw. möglicherweise schon lange für etwas anderes benutzt wird.

Mit solchen Konstruktionen kann man sich in C schön selbst verarschen,
wenn man nicht weiß was man tut.

Im Prinzip etwas ähnliches macht man mit dem obigen falschen Beispiel:

<c>
// liest eine Zeile (maximal ... Zeichen) und liefert sie als
// nullterminierten String zurück:
char* uart_get_line()
{
char string[10];
uint8_t i = 0;

for( ... )
{
...
string[i] = ...;
...
}
string[i] = '\0';
return string; // nicht *string
}

...
char* meinezeile;
meinezeile = uart_get_line();
printf( "gelesen: %s", meinezeile );
...
</c>

(Es soll jetzt mal egal sein, daß es ein printf() in dieser Form gar
nicht auf einem AVR gibt; es geht nur darum, den String irgendwie zu
verwenden.)

Was passiert bei diesem Beispiel?
in uart_get_line() gibt es eine lokale (automatische) Variable string;
das ist ein Feld mit 10 Zeichen.
Beim Rücksprung wird die Adresse des ersten Elements zurückgegeben und
beim Aufrufer in meinezeile gespeichert. meinezeile ist also ein Zeiger auf das erste Zeichen von string. Der springede Punkt ist: Die Variable string existiert nach Verlasse4n der Funktion gar nicht mehr! Man hat daher einen Pointer, der auf etwas Ungültiges zeigt. Da muss nicht unbedingt heißen, dass es nicht so aussehen kann, als ob so etwas funktionieren würde. Solange der Speicherplatz der ehemaligen Variablen string nicht für andere Zwecke gebraucht wurde, kann man unter Umständen sogar über den Pointer an die korrekten Zeichen kommen. Der physikalische Speicher verschwindet ja nicht irgendwie magisch. Der ist schon noch da. Nur haben wir keine Garantie, dass auch das drinnen steht, was unserer Meinung nach drinnen stehen sollte, denn dieser Speicher ist ja nicht mehr für die ausschliessliche Verwendung durch die Variable string reserviert.

Bei soetwas muß man in C ziemlich nervös werden!
So ist es jedenfalls Murks.

Es gibt mehrere Möglichkeiten, das zu verbessern,
Leider sind sie alle nicht richtig schick, jede Variante ist irgendwie
etwas doof.

=== Erste Möglichkeit: Den String static machen ===
Dann ist es keine automatische Variable mehr, die daher auch nicht beim Verlassen der Funktion zerstört wird:
<c>
// liest eine Zeile (maximal ... Zeichen) und liefert sie als
// nullterminierten String zurück:
char* uart_get_line()
{
static char string[10];
uint8_t i = 0;

for( ... )
{
...
string[i] = ...;
...
}
string[i] = '\0';
return string; // nicht *string
}

...
char* meinezeile;
meinezeile = uart_get_line();
printf( "gelesen: %s", meinezeile );
...
</c>

Damit klappt es auf einmal wundersamerweise.
Eine static-Variable wird nicht immer neu angelegt und wieder
wegegworfen, sondern existiert einmal von Programmstart bis
Programmende.

Aber wo ist dabei der Haken?
Daß sie eben nur einmal existiert.
<c>
...
char* meinezeile1;
char* meinezeile2;

meinezeile1 = uart_get_line();
printf( "gelesen1: %s", meinezeile1 ); // gibte erste Zeile aus
meinezeile2 = uart_get_line();
printf( "gelesen2: %s", meinezeile2 ); // gibte zweite Zeile aus

printf( "gelesen1: %s", meinezeile1 ); // gibte zweite Zeile aus (!)
printf( "gelesen2: %s", meinezeile2 ); // gibte zweite Zeile aus
...
</c>

In diesem Beispiel sieht es erst vernünftig aus: mit meinezeile1 wird
die erste gelesene Zeile ausgegeben, mit meinezeile2 dann die zweite.
Mit der folgenden Ausgabe wird sowohl für meinezeile1 als auch für
meinezeile2 nur noch die letzte gelesene Zeile (also die zweite)
ausgegeben, weil in der static-Variable string ja mit der zweiten
Zeile die erste überschrieben wurde und sowohl meinezeile1 als auch meinezeile2 ja Zeiger auf dieses eine Array sind.

Das wird der Aufrufer so wahrscheinlich nicht erwarten; das ist also
doch etwas problematisch.
Richtig krank werden static-Variablen bei Programmen, die mit mehreren
Threads arbeiten, ebenso wie bei rekursiven Funktionsaufrufen.
Leider sind mehrere Funktionen der Standard-Lib von C mit statischen
Variablen gebaut und deshalb nicht benutzbar in
multitasking-Programmen (strtok() z.B. fällt auf die Klappe).

=== Zweite Möglichkeit: dynamische Allokierung ===
Eine andere Lösung wäre: in der Funktion wird für den gelesenen String
Speicher allokiert und der Zeiger darauf zurückgegeben:
<c>
// liest eine Zeile (maximal ... Zeichen) und liefert sie als
// nullterminierten String zurück:
char * uart_get_line()
{
uint8_t i = 0;

char* string = malloc( genugzeichen.... );
for( ... )
{
...
string[i] = ...;
...
}
string[i] = '\0';
return string;
}

...
char* meinezeile;
meinezeile = uart_get_line();
printf( "gelesen: %s", meinezeile );
free( meinezeile ); // Speicher nach letzter Benutzung freigeben
...
</c>

Das würde jetzt auch bei Multitasking funktionieren ebenso wie bei
Rekursion.

Und wo ist hier der Haken?
In der Funktion wird Speicher allokiert, und erst der Aufrufer kann den
Speicher freigeben - wenn er es nicht vergisst.

Leider wird es mehr oder weniger häufig vergessen, weswegen es als
höchst unelegant gilt, in einer Funktion Speicher zu allokieren, der
vom Aufrufer wieder freigegeben werden muß.

Auf einem Controller wird man diese Lösung auch nicht gerne sehen,
weil es da wegen des knappen Speichers selten ratsam ist, dynamische
Speicherverwaltung mit malloc() zu nutzen.
Ich hatte hier ja auch die Fehlerbehandlung unterschlagen: Was soll
passieren, wenn gar kein Speicher allokiert werden kann? Auf einem
Controller kann man ja nicht einfach eine kurze Meldung ausgeben und
das Programm beenden. Ein Absturz wird auch nicht gern gesehen und
nicht so leicht akzeptiert wie unter Windows.

=== Dritte Möglichkeit: Allokierung durch den Aufrufer ===
Der Aufrufer selbst beschafft den Platz, übergibt
ihn und die Funktion schreibt nur rein:

<c>
// liest eine Zeile (maximal ... Zeichen) und liefert sie als
// nullterminierten String zurück:
char * uart_get_line( char* string, size_t l_puffer )
{
uint8_t i = 0;

for( ... && i<l_puffer-1 )
{
...
string[i] = ...;
...
}
string[i] = '\0';
return string;
}

...
char meinezeile[10];
uart_get_line( meinezeile, 10 );
printf( "gelesen: %s", meinezeile );
...
</c>

Weil die Funktion nicht feststellen kann, wie groß der Puffer ist, muß
der Aufrufer auch gleich die Länge übergeben.

Das hat nebenbei den Vorteil, daß man in der Funktion nicht mehr
spekulieren muß, wieviel Platz nötig ist (wie kommt man gerade auf die 10?
Woher soll man das in der Funktion wissen?). Die Funktion kann also je nach Situation mal mit einem großen oder mal mit einem kleinen Puffer aufgerufen werden.
Dafür hat man aber wieder das umgekehrte Problem: Was ist, wenn der Aufrufer nicht weiß oder wissen kann, wie groß ein String werden kann. Besonders problematisch ist das zb. bei Benutzereingaben oder in Situationen in denen der String durch Datenübertragung entsteht. Niemand kann zuverlässig vorhersagen, wieviele Zeichen ein Benutzer eingeben wird. Nur: Wie soll der Aufrufer einer entsprechenden Funktion dies dann wissen?

Nachteil dieser Lösung ist ausserdem, daß der Aufruf etwas umständlich ist (2
Parameter mehr).

=Funktionszeiger=
Um Menüs oder ähnliche Dinge aufzubauen ist es oft praktisch ein Array von Funktionszeigern zu definieren. Der Aufruf einer Funktion kann dann indirekt über eine Variable erfolgen, wobei die Variable die Adresse der aufzurufenden Funktion enthält.

Um mit Funktionszeigern zu arbeiten ist es in der Praxis sinnvoll sich einen typedef für den Typ des Funktionszeigers zu definieren. Ein typedef definiert einen neuen (kürzeren) Namen für einen Datentyp. Und wie wir sehen werden, ist der Datentyp eines Funktionszeigers in der Schreibweise ganz schön umfangreich.

==typedef==
Einen typedef zu definieren ist eigentlich ganz einfach: Man schreibt die Deklaration so, als ob man eine Variable definieren würde. Vor das ganze Konstrukt kommt das Schlüsselwort typedef. Es bewirkt, dass der Name an der Position des Variablennamens zum Namen für den neuen Datentyp wird, der dann in weiterer Folge wie jeder andere Datentyp benutzt werden kann.

Wir wollen einen Funktionszeiger auf eine Funktion definieren, die keine Argumente entgegen nimmt und auch nichts liefert. Also Funktionen nach
dem Muster:

<c>
void foo( void )
{
}
</c>

Ein entsprechender typedef würde zB so aussehen:

<c>
typedef void (*VoidFnct)( void );
</c>

Das vereinbart einen neuen Datentyp VoidFnct. Dieser ist ein Funktionszeiger auf Funktionen, die keine Argumente nehmen und auch nichts zurückliefern.

<c>
typedef int (*IntFnct)( void );
typedef int (*IntFnct2)( int );
</c>

IntFnct ist ein Zeiger auf eine Funktion, die keine Argumente nimmt aber einen int zurückliefert. IntFnct2 hingegen ist ein Zeiger auf eine Funktion, die einen int als Argument nimmt und einen int zurückliefert. Andere Argumenttypen bzw. Rückgabetypen folgen dem gleichen Muster. Wichtig ist, dass sowohl Argumenttypen als auch Rückgabetypen Teil der Signatur eines Funktionszeigers ist. Es ist also nicht möglich einen Funktionszeigertyp zu vereinbaren, der auf beliebige Funktionen mit beliebigen Argumenttypen bzw. Rückgabetypen verweist. Hier muss man ev. auf einen cast ausweichen. Generell ist das aber meist keine gute Idee.

Die Bildung des Datentyps ist im Grunde eigentlich sehr einfach: Man nimmt in Gedanken den Funktionskopf her.
<c>
double CelsiusToFahrenheit( double Celsius )
{
...
</c>
Dann werden in der Argumentliste alle Argumentnamen entfernt
<c>
double CelsiusToFahrenheit( double )
</c>
Der Funktionsname durch den Namen des Datentyps getauscht
<c>
double CallbackFnct( double )
</c>
Vor den Datentypnamen kommt ein * (wie bei allen Zeigerdefinitionen) und rund um dieses Gebilde kommen Klammern (die den * an den Datentypnamen binden und nicht an den Datentyp des Returnwertes)

<c>
double (*CallbackFnct)( double )
</c>

und fertig ist der Datentyp einer Funktion die einen double als Argument annimmt und einen double als Returnwert liefert. Davor noch der typedef und das abschliessende ; und wir haben einen neuen Datentyp namens CallbackFnct, der einen Funktionszeiger auf Funktionen mit genau dieser Signatur darstellt.

<c>
typedef double (*CallbackFnct)( double );
</c>

==Funktionszeigertabellen==
Mit einem typedef ist es nun ein leichtes ein Array von Funktionszeigern zu vereinbaren:

<c>
typedef void (*VoidFnct)( void );

VoidFnct MeineFunktionen[5];
</c>

===Im RAM===
Dies vereinbart MeineFunktionen als ein Array von Funktionszeigern, wobei jeder Funktionszeiger auf eine Funktion vom Typ void-void zeigt. Diese Tabelle liegt im RAM ab.

<c>
typedef void (*VoidFnct)( void );

void Funct1()
{
printf( "Dies ist Funktion 1\n" );
}

void Funct2()
{
printf( "Dies ist Funktion 2\n" );
}

VoidFnct MeineFunktionen[] = { Funct1, Funct2 };

int main()
{
//
// ruft die Funktion auf, deren Adresse in MeineFunktionen[0]
// steht. In diesem Fall wäre das Funct1()
//
MeineFunktionen[0]();

//
// und jetzt die MeineFunktionen[1]
//
MeineFunktionen[1]();

//
// jetzt wird MeineFunktionen[0] umgeleitet auf Funct2()
// Achtung: Auf der rechten Seite wird kein () angegeben.
// Ansonsten würde ja die Funktione Funct2 aufgerufen. Wir
// wollen aber nur ihre Speicheradresse haben! Daher unterbleibt
// das ()
//
MeineFunktionen[0] = Funct2;

//
// welche Funktion wird jetzt aufgerufen?
//
MeineFunktionen[0]();
// Richtig: Die Funktion, deren Adresse in MeineFunktionen[0]
// steht. Und das ist jetzt Funct2.
}
</c>

===Im Flash===
Steigt die Anzahl der Funktionen innerhalb der Tabelle stark an und soll deren Inhalt nicht veränderbar sein, kann die sie in den FLASH verlegt werden. Das spart die entsprechenden RAM Ressourcen.

<c>
//
// stellt Zugriffsfunktionen für FLASH zur Verfügung
//
#include <avr/pgmspace.h>

typedef void (*VoidFnct)( void );

void Funct1()
{
printf( "Dies ist Funktion 1\n" );
}

void Funct2()
{
printf( "Dies ist Funktion 2\n" );
}

// legt die Tabelle im FLASH ab
const VoidFnct MeineFunktionen[] __attribute__ ((progmem)) = { Funct1, Funct2 };

int main()
{
//
// legt eine Variable an die mit der Funktionsadresse aus
// der Tabelle (die im Flash abliegt) gefüllt wird.
//
VoidFnct MeineFunktion = 0u;

//
// Lädt die Adresse der Funktion die an MeineFunktionen[0]
// steht
//
MeineFunktion = (VoidFnct)(pgm_read_word(&(MeineFunktionen[0u])));

//
// ruft MeineFunktion auf, welche nun auf die Adresse von
// MeineFunktionen[0] zeigt. In diesem Fall wäre das Funct1()
//
MeineFunktion();

//
// und jetzt die an MeineFunktionen[1], also Funct2()
//
MeineFunktion = (VoidFnct)(pgm_read_word(&(MeineFunktionen[1u])));
MeineFunktion();
}
</c>

==Menüs mit Funktionszeigern==
Besonders bei Menüs ist es oft hilfreich, sich eine Struktur bestehend
aus dem Menütext und der aufzurufenden Funktion zu definieren. Dazu kann man sich dann auch gleich noch irgendwelche Argumente mit in die Struktur mit aufnehmen, die beim Funktionsaufruf an die Funktion übergeben werden.

<c>
typedef void (*MenuFnct)( int);

struct MenuEntry {
char Text[20];
MenuFnct Function;
int ArgumentToFunction;
};
</c>

Ein Menü ist dann einfach ein Array aus derartigen Strukturelementen

<c>

void HandleEdit( int arg )
{
}

void HandleCopy( int arg )
{
}

void HandlePaste( int arg )
{
}

struct MenuEntry MainMenu[] = {
{ "Edit", HandleEdit, 23 }, // Der Funktion HandleEdit soll beim Aufruf 23 mitgegeben werden
{ "Copy", HandleCopy, 0 },
{ "Paste", HandlePaste, 0 }
};

#define ARRAY_SIZE(X) ( sizeof(X) / sizeof(*(X)) )

void DoMenu( int NrEntries, struct MenuEntry Menu[] )
{
int i;
int Auswahl;

do {
//
// Das Menue anzeigen. Für jeden Menuepunkt noch eine Zahl
// davor stellen, damit der Benutzer auch was zum Eingeben hat
//
for( i = 0; i < NrEntries; ++i )
printf( "%d) %s\n", i + 1, Menu[i].Text );

printf( "9) Exit\n\n" );

//
// Jetzt die Benutzereingabe abwarten ...
//
printf( "Ihre Eingabe: " );
scanf( "%d", &Auswahl );

//
// ... und auswerten
//
if( Auswahl == 9 )
return;

Auswahl = Auswahl - 1;
if( Auswahl < 0 || Auswahl > NrEntries )
printf( "Ungültige Eingabe\n" );

else
//
// Die Eingabe war gültig. Zugehörige Funktion aufrufen und der Funktion
// den in der Menüdefinition vermerkten Wert mitgeben
//
Menu[Auswahl].Function( Menu[Auswahl].ArgumentToFunction );
}
}

int main()
{
// Das Menü arbeiten lassen.
// Die Funktion DoMenu ruft selbsttätig die zu den jeweiligen
// Menüpunkten gehörenden Funktionen auf. DoMenu kommt erst
// dann wieder zurück, wenn der Benutzer den Menüpunkt
// 9) Exit
// ausgewählt hat.

DoMenu( ARRAY_SIZE( MainMenu ), MainMenu );

while( 1 )
;
}
</c>

Auf einem Mikrocontroller wird man natürlich die Ein/Ausgabe nicht über printf/scanf abwickeln. Hier geht es aber um das Prinzip der Funktionszeiger und wie man mit ihnen arbeitet, daher wurde die allereinfachste Art der Benutzerinteraktion gewählt. Gegebenenfalls muss printf und scanf durch die Möglichkeiten auf dem konkreten System ersetzt werden. Auch ist die Art und Weise wie das Menü präsentiert bzw. die Benutzereingabe ausgewertet wird, nicht der Weisheit letzter Schluss. Anstatt den Benutzer Zahlen eingeben zu lassen, könnte man auch einen Auswahl-Balken vom Benutzer mit 2 Tasten über die Menüeinträge bewegen lassen. Oder einen Drehencoder nehmen, ...

=Ich hab da mehrere *.c und *.h Dateien. Was mache ich damit?=
Zunächst ist es wichtig, sich zu vergegenwärtigen wie denn der C Compiler/Linker überhaupt arbeitet. Ein komplettes Programmier-Projekt kann und wird im Normalfall aus mehreren Source Code Dateien bestehen die alle zusammengenommen das komplette Programm bilden.

Der Prozess des Erstellens des Programmes geschieht in mehrerern Schritten:
* zunächst werden alle Einzelteile (jede *.c Datei) für sich ''compiliert''. Dabei ensteht für jede *.c Datei eine sog. Object-Datei in der bereits der Maschinencode für die im *.c programmierten Funktionen enthalten ist
* danach werden die einzelnen Object-Dateien zusammen mit zusätzlichen Bibliotheken zum fertigen Programm ''gelinkt''.

Angenommen das komplette Projekt besteht aus 2 Dateien

Datei: main.c
<c>
int twice(int i);

int main()
{
twice( 5 );
}
</c>

Datei: func.c
<c>
int twice( int number )
{
return 2 * number;
}
</c>

dann werden main.c und func.c unabhängig voneinander compiliert. Als Ergebnis erhält man die Dateien main.o und func.o die den besagten Object-Code enthalten. Erst diese beiden Zwischenergebnisse werden dann zusammen mit eventuellen Bibliotheken zum fertigen Programm gebunden (gelinkt), das dann ausgeführt werden kann.

+---------+ +----------+
| main.c | | func.c |
+---------+ +----------+
| |
| |
v v
Compiler Compiler
| |
| |
v v
+---------+ +----------+
| main.o | | func.o |
+---------+ +----------+
| |
+-----------+ +-------------------+
| |
v v
Linker <------ zus. Bibliotheken
|
v
+----------+
| fertiges |
| Programm |
+----------+

Bekommt man also von irgendwo bereits fertige *.c (und zugehörige *.h) Dateien, so genügt es, die *.c Dateien ganz einfach in das Projekt mit aufzunehmen. Daduch wird das entsprechende *.c File compiliert und das Ergebnis davon, das Object-file, wird dann in das fertige Programm mit eingelinkt.

Wie eine *.c Datei in das Projekt mit aufgenommen wird, hängt im wesentlichen von der benutzten Entwicklungsumgebung ab.

==Makefile==
Die zusätzliche *.c Datei wird in die SRC Zeile im makefile eingetragen.
==AVR-Studio==
Hier ist es besonders einfach eine Datei in das Projekt mit aufzunehmen. Dazu wird im Projektbaum einfach der Knoten "Source Files" aktiviert und mit der rechten Maustaste das Kontextmenü geöffnet. Im Menü wird der Punkt "Add existing Source File(s)" ausgewählt und anschliessend zeigt man AVR-Studio das zusätzliche *.c File. AVR-Studio berücksicht dann dieses File bei der Projekterzeugung, compiliert es und sorgt dafür, daß es zum fertigen Programm dazugelinkt wird.

=Globale Variablen über mehrere Dateien=
Ein häufige Problemkreis in der C Programmierung sind auch globale Variablen, die von mehreren *.c Dateien aus benutzt werden sollen. Was hat es damit auf sich?

Zunächst mal muß man bei der Vereinbarung von Variablen zwischen Definition und Deklaration unterscheiden. Worin besteht der Unterschied?
* Definition: Mit einer Definition wird der Compiler angewiesen, eine Variable tatsächlich zu erzeugen. Damit er das kann, muß ihm selbstverständlich der exakte Datentyp und auch der Name der Variablen zur Verfügung stehen. Eine Definition sorgt also dafür, dass im späteren Programm Speicherplatz für diese Variable reserviert wird
* Deklaration: Mit einer Deklaration teilt man dem Compiler lediglich mit, dass eine Variable existiert. An dieser Stelle soll der Compiler also keinen Speicherplatz reservieren (das muß an anderer Stelle geschehen sein), sondern der Compiler soll einfach nur zur Kenntniss nehmen, daß es eine Variable mit einem bestimmten Namen gibt und von welchem Datentyp sie ist.

Aus obigem folgt sofort, dass eine Definition auch immer eine Deklaration ist. Denn dadurch daß der Compiler angewiesen wird eine Variable auch tatsächlich zu erzeugen folgt, dass er dazu auch dieselben Informationen benötigt, die auch in einer Deklaration angegeben werden müssen. Der einzige Unterschied: Bei einer Deklaration trägt der Compiler nur in seinen internen Tabellen ein, dass es diese Variable tatsächlich gibt, während er bei einer Definition zusätzlich auch noch dafür sorgt, dass im fertigen Programm auch noch Speicher für diese Variable bereitgestellt wird.

Warum ist diese Unterscheidung jetzt wichtig?

Weil es in C die sog. One Definition Rule oder kurz ODR gibt. Sie besagt, dass in einem vollständigem Programm, also über alle *.c Dateien gesehen, es für eine Variable nur eine Definition geben darf. Es darf allerdings beliebig viele Deklarationen geben, solange diese Deklarationen alle im Datentyp übereinstimmen. Kurz gesagt: Man darf den Compiler nur einmal auffordern eine Variable zu erzeugen (Definition), kann sich aber beliebig oft auf diese eine Variable beziehen (Deklarationen). Aber Vorsicht! Da der Compiler jede einzelne *.c Datei für sich alleine übersetzt und dabei kein Wissen von ausserhalb benutzt, obliegt es der Verantwortung des Programmierers dafür zu sorgen, dass alle Deklarationen im Datentyp übereinstimmen. Der Compiler kann diese Einhaltung prinzipbedingt nicht überwachen!

Woran erkennt man eine Definition bzw. Deklaration?

Eine Definition einer globalen Variable steht immer ausserhalb eines Funktionsblocks. Zb.
<C>
int MyData; // Globale Variable namens MyData. Sie ist vom Typ int
char Name[30]; // Globales Array
long NrElements = 5; // Globale Variable, die auch noch initialisiert wird
</C>

Eine Deklaration unterscheidet sich von einer Definition in 2 Punkten
* Es wird das Schlüsselwort extern vorangestellt.
* Es kann keine Initialisierung geben. Sobald eine Initialisierung vorhanden ist, wird das Schlüsselwort extern ignoriert und aus der Deklaration wird eine Definition.

Beispiele für Deklarationen
<C>
extern int MyData;
extern char Name[30];
extern long NrElements;
extern long NrElements = 5; // Achtung: Dies ist keine Deklaration!
</C>

Besitzt man also 2 *.c Dateien, main.c und helpers.c, und sollen sich diese beiden Dateien eine globale Variable teilen, so muss in eine Datei eine Definition hinein, während in die andere Datei eine Deklaration derselben Variablen erfolgen muß. Traditionell werden die Definitionen in der Datei gemacht, die auch die main() Funktion enthält. Das muss nicht so sein, ist aber eine Konvention, die oft Sinn macht. Alternativ wird auch gerne oft eine eigene *.c Datei (zb. globals.c) gemacht, die einzig und alleine die Defintionen der globalen Variablen enthält.

main.c
<C>
int AnzahlElemente; // Dies ist die Definition. Hier wird die globale
// Variable AnzahlElemente tatsächlich erzeugt.

int main()
{
AnzahlElemente = 8;
...
}
</C>

helpers.c
<C>
extern int AnzahlElemente; // Dies ist die Deklaration die auf die globale
// Variable AnzahlElemente in main.c verweist.
// Wichtig: Der Datentyp muss mit dem in main.c
// angegebenen übereinstimmen

void foo()
{
...
j = AnzahlElemente;
AnzahlElemente = 9;
}
</C>

==Praktische Durchführung==
Besteht ein vollständiges Programm aus mehreren *.c Dateien, dann kann man sich vorstellen, daß es mühsam ist, alle Deklarationen immer auf gleich zu halten. Hier bietet sich der Einsatz eines Header Files an, in der die Deklarationen stehen und welches in die jeweiligen *.c Dateien inkludiert wird

Bsp:

Global.h
<C>
extern int Anzahl;
</C>

main.c
<C>
#include "Global.h"

int Anzahl; // auch wenn Global.h inkludiert wurde, so muss es eine
// Definition der Variablen geben. In Global.h sind ja nur
// Deklarationen.

int main()
{
...
Anzahl = 5;
}
</C>

foo.c
<C>
#include "Global.h"

void foo()
{
...
Anzahl = 8;
...
}
</C>

bar.c
<C>
#include "Global.h"

void bar()
{
...
j = Anzahl;
}
</C>

Auf diese Art kann man erreichen, dass zumindest alle Deklarationen ein und derselben Variablen in einem Programm übereinstimmen. Die Datei Global.h wird auch in main.c inkludiert, obwohl man das eigentlich nicht müsste, denn dort wird die Variable ja definiert. Durch die Inclusion ermöglicht man aber dem Compiler die Überprüfung ob die Deklaration auch tatsächlich mit der Definition übereinstimmt.

Solange kein Initialisierungen der globalen Variablen notwendig sind, gibt es noch einen weiteren Trick, um sich selbst das Leben und die Verwaltung der globalen Variablen zu erleichtern.
Worin besteht das Problem?
Das Problem besteht darin, dass man bei Einführung einer neuen globalen Variablen an 2 Stellen erweitern muss: Zum einen in der Header-Datei, die die 'extern'-Deklaration der Variablen enthält, zum anderen muss in einer C-Datei die Definition der Variablen erfolgen. Das kann man sich mit etwas Präprozessorarbeit auch einfacher machen:

Global.h
<C>
#ifndef EXTERN
#define EXTERN extern
#endif

EXTERN int Anzahl;
</C>

main.c
<C>
#define EXTERN
#include "Global.h"

int main()
{
...
Anzahl = 5;
}
</C>

foo.c
<C>
#include "Global.h"

void foo()
{
...
Anzahl = 8;
...
}
</C>

Wie funktioniert das Ganze? Im Grunde muss man nur dafür sorgen, dass der Compiler an ''einer'' Stelle das Schlüsselwort '''extern''' ignoriert (hier in main.c) und bei allen anderen Inclusionen beibehält. Dadurch das ein Präprozessor-ifndef benutzt wird, kann dieses erreicht werden. Wird das Header File includiert und ist zu diesem Zeitpunkt das Makro '''EXTERN''' noch nicht definiert, so wird innerhalb des Header Files '''EXTERN''' zu '''extern''' definiert und damit in weiterer Folge im Quelltext '''EXTERN''' durch '''extern''' ersetzt. Wenn daher foo.c das Header File inkludiert, wird die Zeile
<C>
EXTERN int Anzahl;
</C>
vom Präprozessor zu
<C>
extern int Anzahl;
</C>
umgewandelt.

In main.c hingegen sieht die Include-Sequenz so aus
<C>
#define EXTERN
#include "Global.h"
</C>
Wenn Global.h bearbeitet wird, existiert bereits ein Makro '''EXTERN''', das auf einen leeren Text expandiert. Dadurch wird verhindert, dass innerhalb von Global.h das Makro '''EXTERN''' mit dem Text '''extern''' belegt wird und
<C>
EXTERN int Anzahl;
</C>
wird daher vom Präprozessor zu
<C>
int Anzahl;
</C>
erweitert, genau wie es benötigt wird.

= Konstanten an fester Flash-Adresse =

Wie kann man eine Konstante an entsprechender Adresse im Flash ablegen?

Mehmet Kendi hat eine Lösung für [[AVR Studio]] & [[WinAVR]] in
[http://www.mikrocontroller.net/topic/142704#1453079] angegeben.

[[Kategorie:Grundlagen]]
[[Kategorie:C]]

Zeitgesteuerte Pflanzenbewässerung

2010-05-14T09:34:35Z

80.72.130.218: /* Downloads */

von Philipp Kälin [[Benutzer:philippk]]

= Einleitung =
Die zeitgesteuerte Bewässerungsanlage ist für alle geeignet, die zu faul sind um Pflanzen selber zu giessen oder es immer wieder mal vergessen. Ziel des Projektes ist einen einfachen Aufbau zu haben, der per PC konfigurierbar und Batteriebetrieben ist.
Ein Taster ist vorhanden um die Kommunikation mit dem PC zu aktivieren. Ist die Kommunikation aktiv leuchtet eine LED konstant. Im normalbetrieb ist die LED aus und fängt an zu blinken, wenn die Spannung der Batterie unter einen bestimmten Wert fällt.
Um die Pumpe für Testzwecke oder manuell einzuschalten ist der Taster S2 vorgesehen.

= Features =
* Batteriebetrieben
* Über PC konfigurierbar
* Einfacher Aufbau ohne komplizierte Feuchtemessung

= Aufbau =
== Mechanisch ==
Der Hauptteilbesteht aus einer Membranpume, die mit einem Wasser-Vorratsbehälter verbunden ist. Es ist darauf zu achten, dass eine Membranpumpe von sich aus nicht sperrt, das heisst wenn der Wasserspiegel im Vorratsbehälter höher ist als der in der Pfalnze so fliesst Wasser von alleine! Als Wasserverteiler dient ein festes Kunststoffröhrchen mit seitlich gebohrten Löchern.

=== Fotos des Aufbaus ===
[[Bild:Bewaesserung_Aufbau.jpg|center|thumb|200px|Aufbau]]
[[Bild:Bewaesserung_Wasserverteiler.jpg|center|thumb|200px|Wasserverteiler]]

Die Schwedenflaggen gibt übrigens wie auch den Wasserbehälter in der Ikea (Ursprünglicher Verwendungszweck: Aufbewahrungsbox für Zucker usw.)

== Hardware ==
Die generelle Funktion sollte aus dem Schema erkennbar sein, hier wird nur auf ein paar spezielle Sachen hingewiesen. Generell kann die Schaltung in folgende Teile unterteilt werden:
* Spannungsregelung 5V
* Schalter, Taster und LED
* Prozessor mit Uhrenquarz
* RS232 Kommunikation
* Ansteuerung der Pumpe mit StepUp Konverter

=== Schema ===
[[Bild:Bewaesserung_Schema.png|center|thumb|200px|Schema]]

=== Spezialitäten der Schaltung ===
Im Betrieb ist der grösste Stromverbraucher der MAX232, deshalb kann diesem die Betriebsspannung mit dem Schalter S1 weggenommen werden, zugleich wird auch die Kommunikation Softwaremässig deaktiviert.

Um die Akkuspannung zu Messen ist ein spezieller Spannungsteiler (R1, R6) vorhanden. R1wird nur gerade während der Messung auf Low gezogen, damit wird erreicht dass der Ruhestrom nur gerade (Vbatt – 5V) / R6 beträgt und nicht Vbatt / (R1 + R6) wie wenn der Widerstand konstant auf GND wäre, was einen erheblichen Unterschied macht.

=== Eventuelle Anpassungen der Hardware ===
Der StepUp Wandler muss natürlich an die Pumpenspannung angepasst werden. Falls man eine genügend hohe Spannung zur verfügung hat kann man auch den FET Q2 durch einen Leistungsfet ersetzen und die Pumpe oder ein Relais direkt schalten.

=== Fotos der Hardware ===
[[Bild:Bewaesserung_Frontplatte.jpg|center|thumb|200px|Frontplatte]]
[[Bild:Bewaesserung_Rueckplatte.jpg|center|thumb|200px|Rückplatte]]
[[Bild:Bewaesserung_Innenleben.jpg|center|thumb|200px|Innenleben]]

= Software =
Die Software ist komplett in C geschrieben und mehr auf einfachheit als volle optimierung ausgerichtet, das erklärt auch dass die 4K des Atmega48 rand voll sind. Alle Einstellungen ausser der aktuellen Zeit und dem aktuellen Wochentag werden im EEPROM abgespeichet und sind nache einem Stomausfall wieder vorhanden.

= Kommunikation =
Die Kommunikation verläuft über RS232 und kann mit jedem "anständigen" Terminalprogramm konfiguriert werden. Ich empfehle für diesen Zweck das kostenlose Termite [[http://www.compuphase.com/software_termite.htm]] für Windows.

== Terminaleinstellungen ==
{| class="wikitable"
|-
! Baudrate
| 2400
|-
! Daten Bits
| 8
|-
! Stop Bits
| 1
|-
! Parity Bit
| keins
|-
! Flusssteuerung
| keine
|-
! Zeilenumbruch
| CR <nowiki>0x0d</nowiki>
|-
|}
[[Bild:Bewaesserung_Termite_Settings.png|center|thumb|200px|Terminaleinstellungen]]

== Kommunikation starten ==
Die Kommunikation wird gestartet indem man den Befehl "status" sendet, danach sollte etwa folgendes zurückkommen:
[[Bild:Bewaesserung_Termite_Window.png|center|thumb|200px|Kommunikation]]

== Parameter ==
::{| class="wikitable" style="text-align:center"
! Befehl || Parameter || Beschreibung
|-
| <nowiki>time</nowiki> || <nowiki>hh:mm</nowiki> || Aktuelle Uhrzeit
|-
| <nowiki>weekday</nowiki> || <nowiki>x</nowiki> || Wochentag (1=Mo 7=So)
|-
| <nowiki>days</nowiki> || <nowiki>xxxxxxx</nowiki> || Wochentage an denen die Pumpe aktiv ist. 0 oder 1 für jeden Wochentag Mo – So
|-
| <nowiki>active</nowiki> || <nowiki>sss</nowiki> || Einschaltzeit in Sekunden in der die Pumpe aktiv ist
|-
| <nowiki>daytime</nowiki> || <nowiki>hh:mm</nowiki> || Tageszeit zu der die Pumpe beginnt zu laufen
|}

Wichtig ist, dass man die Anzahl Zeichen einhält, will man also eine Einschaltzzeit vo 2 Sekunden erreichen, so muss <nowiki>active 002</nowiki> gesendet werden.

= Alternativen / Erweiterungen =
Natürlich kann dieses Projekt nicht nur als Steuerung für eine Pumpe dienen, sondern als beliebige Tageszeitschaltuhr.

= Downloads =
Schema und Software sind OpenSource und können vom SVN heruntergeladen werden. Die Ordnerstruktur ist in der README Datei im Rootverzeichnis erklärt. http://www.mikrocontroller.net/svnbrowser/bewaesserung/

ENC28J60

2010-04-16T11:46:57Z

80.72.130.218: /* Reichelt */

Der ENC28J60 ist ein Ethernet-Controller von Microchip. Das besondere ist die handliche Bauform (unter anderem PDIP-28) und das SPI-Interface.

==Projekte==
*[http://avr.auctionant.de/avrETH1/ winziger Webserver (komplett SMD, mehrseitig) mit enc28j60 und atmega32(avrETH1)] (02.03.2006)
*[http://home.arcor.de/fuenfundachtzig/me/me.htm E-Mail-Client mit dem ENC 28J60 und dem ATmega32 (ME)] (28.03.2006)
*[http://www.lochraster.org/etherrape generische Platform (ohne SMD-Teile) für viele Applikationen ("etherrape"), enc28j60 mit atmega644] (29.11.2006)
* https://berlin.ccc.de/wiki/Mikrocontroller (barebone, kein Zubehör bestückt, ohne SMD)
* [http://www.ulrichradig.de/home/index.php/avr/eth_m32_ex ATmega32/644 Webserver ohne SMD!] (23.11.2007)
* [http://www.triplay.de/zeigeprojekt.php?id=22 ATmega644 Webserver und Webcam auf einseitiger SMD Platine. Mit Tipps zur Programmierung des enc28j60] (16.12.2007)
* [[Miniwebserver]]
* [http://www.ethersex.de/ Umfassendes Projekt mit IPv6, RFM12 und vieles mehr]
* [http://wiki.neo-guerillaz.de/mediawiki Kleine Platine mit allem was man braucht. Bis auf den AVR alles DIL/DIP. Komplett GPL/OpenSource] (12.10.2008)

==Bezugsquellen==

=== Reichelt ===
* [http://www.reichelt.de/?;ACTION=3;LA=2;GROUPID=2946;ARTICLE=89339;SID=286m1Z4KwQARwAACMOS0g402d9ed30ed809e838679a59c8f75aac ENC 28J60 SO-28] 2,55€
* [http://www.reichelt.de/?;ACTION=3;LA=2;GROUPID=2946;ARTICLE=89340;SID=286m1Z4KwQARwAACMOS0g402d9ed30ed809e838679a59c8f75aac ENC 28J60 DIL-28] ''Stand 2010-04-16 nicht lieferbar''

=== Mikrocontroller.net ===
* [http://shop.mikrocontroller.net/?product_id=65 Adapterplatine mit ENC28J60 und Ethernet-Buchse]

===[[Elektronik-Versender#csd-electronics|csd-electronics]]===
*ENC28J60 DIP28S 4,39€ (Best.Nr.: 30362)
*ENC28J60 SOIC28 4,39€ (Best.Nr.: 30363)
*ENC28J60 SSOP28 4,95€ (Best.Nr.: 30365)
*ENC28J60 QFN28 6,95€ (Best.Nr.: 30364)
*MagJack mit 4 Leds 3,45€ (Best.Nr.: 015-54085)
*MagJack mit 2 Leds 4,95€ (Best.Nr.: 015-54084)
*PulseJack mit Leds 2,40€ (Best.Nr.: 015-54087)
*25 MHz-Quarz SMD (Grundton) 0,49€ (Best.Nr.: 14-4S25,000MHZ)
*25 MHz-Quarz (Grundton) 0,35€ (Best.Nr.: 14-US25,000MHZ)
*49.9 Ohm 1% Widerstand 0805 100 Stk 1,00€ (Best.Nr.: 10-080049)

===[[Elektronik-Versender#Microcontroller-Starterkits|microcontroller-starterkits]]===
*ENC28J60 SO28 6,50€ (Best.Nr.: 4019)
*ENC28J60 DIP28 6,50€ (Best.Nr.: 4031)
*MagJack mit Leds 5,50€ (Best.Nr.: 4276)
*25 MHz-Quarz (Grundton) 0,60€ (Best.Nr.: 4182)

===[[Elektronik-Versender#Embedit_Mikrocontrollertechnik|Embedit Mikrocontrollertechnik]]===
*ENC28J60 DIP28 5,99€
*ENC28J60 SO28 5,99€
*ENC28J60 QFN28 5,99€
*Taimag RJLBC-060TC1 RJ45 Buchse mit Übertrager und LEDs 3,99€
*25 MHz-Quarz HC49U/S (Grundton) 0,50€

===[[Elektronik-Versender#IT-WNS|IT-WNS]]===
*ENC28J60 DIP28 4,19€
*ENC28J60 SO28 4,39€
*25 MHz-Quarz SMD (Grundton) 0,65€
*49.9 Ohm 1% Widerstand 0805 Stk 0,03€
*49.9 Ohm 1% Widerstand bedrahtet Stk 0,09€

===[[Elektronik-Versender#Watterott electronic|Watterott electronic]]===
*ENC28J60 SOIC28 3,25€
*ENC28J60 DIL28 3,50€
*MagJack mit LEDs 2,00€
*Würth RJ-45 mit Übertrager, 2 Leds und PoE 6,35€
*Würth RJ-45 mit 2 Leds 1,60€
*Würth SMD Übertrager für PoE 3,15€
*25MHz Grundtonquarz HC49 SMD 0,50€
*25MHz Grundtonquarz CS10 SMD 1,20€

===[[Elektronik-Versender#Pollin_Electronic|Pollin Electronic]]===

* [http://www.pollin.de/shop/shop.php?cf=detail.php&pg=OA==&a=MTQ5OTgxOTk=&w=OTk4OTU4&ts=0 Komplettbausatz AVR-NET-IO] mit Platine, ENC28J60, AVR ATmega32, MagJack usw. 19,95€
* [http://www.pollin.de/shop/detail.php?pg=NQ==&a=NzQxOTk4OTk= ENC28J60] einzelnes IC DIP28. 3,20€
* [http://www.pollin.de/shop/detail.php?pg=NQ==&a=ODk5OTQ1OTk= RJ45-Modularbuchse] mit integriertem Impulsübertrager, 2 LEDs, geschirmt, 8 Pins belegt, abgewinkelt. 1,95€

==Forum==
*[http://www.mikrocontroller.net/forum/read-4-343017.html#new ENC28J60 Basics (Beispielprogramm in AVRGCC für atmega8)] (29.04.2006)
*[http://www.mikrocontroller.net/forum/read-1-310134.html#new winziger Webserver mit enc28j60+mega32] (26.02.2006)
*[http://www.mikrocontroller.net/forum/read-1-179365.html#new Handlicher Ethernet-Controller mit SPI von Microchip] (26.04.2005)
*[http://www.mikrocontroller.net/forum/read-1-291186.html Eagle Platine mit ENC28J60 und AVR Mega8L]
*[http://www.mikrocontroller.net/forum/read-1-355428.html LPC2138 + ENC28J60] (23.05.2006)
*[http://www.mikrocontroller.net/forum/read-1-402627.html I/O über Ethernet mit einem ENC28J60] (19.08.2006)
*[http://www.mikrocontroller.net/topic/82127 Webserver ATmega32/644DIP ENC28J60 (ohne SMD!)] (14.11.2007)
*[http://www.mikrocontroller.net/topic/100177 Erweiterbares Ethernetboard mit MMC/SD-Slot und USB] (17.05.2008)
*[http://www.mikrocontroller.net/topic/109988 AVR für wenig Geld im LAN] (03.09.2008)
*[http://www.mikrocontroller.net/topic/131825 Die andere Firmware für AVR-NET IO] (15.03.2009)

==Hardware==
*[http://www.olimex.com/dev/images/enc28j60-sch.gif Minimalbeschaltung] (Quelle: Olimex)
*[http://www.b-redemann.de/produkte-ethernet.shtml Bausatz Ethernetmodul mit ENC28J60] (Ohne smds, www.b-redemann.de)
* Im [http://shop.mikrocontroller.net/ mikrocontroller.net Shop] das Modul von Olimex (22.04.2008)
*[http://www.ulrichradig.de/ Ulrich Radig] Ethernet ATmega32/644 Experimentierboard (01.09.2008)
*[http://www.pollin.de/ Pollin] Bausatz AVR-NET-IO, ArtNr 810 058 (01.09.2008)
*[http://rz-robotics.de/z-lan.html Z-LAN] bei rz-robotics mit 3,3V-Spannungsregler onboard (26.01.2009).

==Software==
*[http://www.mil.ufl.edu/~chrisarnold/components/microcontrollerBoard/AVR/avrlib/docs/html/ Procyon AVRlib: Network Library ]
*[http://www.sics.se/~adam/uip/ uIP TCP/IP Stack for Embedded Microcontrollers]
*[http://www.ulrichradig.de/ Ulrich Radig] Ethernet ATmega32/644 Experimentierboard (01.09.2008)
*[http://ww1.microchip.com/downloads/en/DeviceDoc/Microchip%20TCPIP%20Stack%20v4.55%20Installer.zip TCP/IP Stack für PIC] von Microchip (26.01.2009)
* [http://wiki.neo-guerillaz.de Der "Hurrican" TCP/IP-Stack vom OpenMCP-Projekt] von Dirk Broßwick für den ATmega644/644P/2561 (15.03.2009)

==Eagle Lib==
*[http://www.mikrocontroller.net/topic/51293 Eagle Lib aus dem Forum]
*[http://www.watterott.com/ENC28J60-SP-DIL28 Eagle Lib von www.watterott.com]

==Datenblatt==
[http://ww1.microchip.com/downloads/en/DeviceDoc/39662b.pdf Link zum Datenblatt]

==Häufige Fehlerursachen==
'''Frage''': Mein ENC28J60 baut einen Link auf und empfängt laut RX Activity LED auch Pakete. Allerdings sind PKTIF und EPKTCNT 0x00. Die SPI Kommunikation arbeitet einwandfrei

'''Antwort''': Die Kondensatoren am Quarz des ENC28J60 spielen eine wichtige Rolle für den Empfang und die Versendung von Paketen. Testweise sollte man den Wert der Kondensatoren verringern (2,2pF haben schon einmal Erfolg gebracht) oder die Kondensatoren komplett entfernen.
Wenn schnelle HostController eingesetzt werden, muss unbedingt auf das Timing des CS-Anschlusses geachtet werden - beim Zugriff auf PHY und MAC Register muss nach der SPI-Übertragung CS 210ns aktiv bleiben.

'''Frage''': Mein ENC28J60 wird recht warm. Ist er kaputt?

'''Antwort''': Nein. Schau mal ins Datasheet unter Stromverbrauch. Je nach Gehäusegrösse äussert sich der in ''warm'' bis ''heiss''.

[[Kategorie:Ethernet]]
[[Kategorie:Bauteile]]

STM32

2010-04-08T11:49:45Z

80.72.130.218: /* Links, Foren, Communities */

'''
== Allgemeine Infos ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 96KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* 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
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 21 AD-Eingängen
* Bis zu 2 12-Bit DA-Wandler
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 3x SPI
* Bis zu 2x I²S
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich Strom sparen lässt
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Der 10-Polige JTAG-Stecker:===

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

=== Installation für STM32 ===

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

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

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

=== Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):===
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

'''
== Errata, Tipps und Tricks ==
'''
* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 7.3.3. Alle Infos von RM0008 7.3.x sind interssant

== Bezugsquellen ==

=== Controller ===
Versandhäuser für Privatpersonen:
* Budelmann Elektronik: http://www.budelmann-elektronik.com (beispielsweise STM32F103RET6 9,00€/Stück, aufgelötet auf SMD-Adapterplatine 12,00€/Stück, momentan nur Anfrage über Kontaktformular möglich)
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+

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

=== Evaluation-Boards ===
* http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14
* http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3
* http://www.sander-electronic.de/es0028.html
* http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher
* http://www.futurlec.com/STM32_Development_Board.shtml

'''

== Links, Foren, Communities ==
'''
* Diskussion zum Artikel: http://www.mikrocontroller.net/topic/173753
* Natürlich hier: http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex*
* https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx
* http://www.stm32circle.com/hom/index.php

STM32

2010-04-08T11:49:15Z

80.72.130.218: /* STM32 */

'''
== Allgemeine Infos ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 96KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* 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
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 21 AD-Eingängen
* Bis zu 2 12-Bit DA-Wandler
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 3x SPI
* Bis zu 2x I²S
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich Strom sparen lässt
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Der 10-Polige JTAG-Stecker:===

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

=== Installation für STM32 ===

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

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

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

=== Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):===
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

'''
== Errata, Tipps und Tricks ==
'''
* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 7.3.3. Alle Infos von RM0008 7.3.x sind interssant

== Bezugsquellen ==

=== Controller ===
Versandhäuser für Privatpersonen:
* Budelmann Elektronik: http://www.budelmann-elektronik.com (beispielsweise STM32F103RET6 9,00€/Stück, aufgelötet auf SMD-Adapterplatine 12,00€/Stück, momentan nur Anfrage über Kontaktformular möglich)
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+

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

=== Evaluation-Boards ===
* http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14
* http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3
* http://www.sander-electronic.de/es0028.html
* http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher
* http://www.futurlec.com/STM32_Development_Board.shtml

'''

== Links, Foren, Communities ==
'''
* Natürlich hier: http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex*
* https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx
* http://www.stm32circle.com/hom/index.php

STM32

2010-04-08T11:30:56Z

80.72.130.218: /* Tipps zur Programmierung */

'''
== STM32 ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 64KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* Externer Quarz
* Real-Time-Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 11 Timer, je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 16 AD-Eingängen
* Bis zu 2 12-Bit DA-Wandler
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 3x SPI
* Bis zu 2x I²S
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* Watchdog mit Window-Mode
* Jedes Peripheriemodul ist separat einschaltbar, wodurch sich erheblich Strom sparen lässt
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

=== Der 10-Polige JTAG-Stecker:===

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

=== Installation für STM32 ===

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

* ST Firmware:
http://www.st.com >> Auswahl CPU STM32F103xxx >> "Firmware" "STM32F10x_StdPeriph_Lib"
http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
In dem ZIP ist ein ZIP mit der Firmware "\Archive\um0427.zip"
Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.2.0\

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

=== Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):===
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

'''
== Errata, Tipps und Tricks ==
'''
* AD-Wandler PA0: Im Errata steht, dass hier Fehler in der Wandlung entstehen könnten, also einen anderen Pin verwenden.
* CAN-Bus PD0/PD1: Remap geht erst ab der 100-Pin-Version. Steht im RM0008 unter 7.3.3. Alle Infos von RM0008 7.3.x sind interssant

== Bezugsquellen ==

=== Controller ===
Versandhäuser für Privatpersonen:
* Budelmann Elektronik: http://www.budelmann-elektronik.com (beispielsweise STM32F103RET6 9,00€/Stück, aufgelötet auf SMD-Adapterplatine 12,00€/Stück, momentan nur Anfrage über Kontaktformular möglich)
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+

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

=== Evaluation-Boards ===
* http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14
* http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3
* http://www.sander-electronic.de/es0028.html
* http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher
* http://www.futurlec.com/STM32_Development_Board.shtml

'''

== Links, Foren, Communities ==
'''
* Natürlich hier: http://www.mikrocontroller.net/forum/mikrocontroller-elektronik?filter=ARM*+STM32*+Cortex*
* https://my.st.com/public/STe2ecommunities/mcu/Lists/ARM%20CortexM3%20STM32/AllItems.aspx
* http://www.stm32circle.com/hom/index.php

STM32

2010-04-08T08:50:53Z

80.72.130.218: /* Evaluation-Boards */

'''
== STM32 ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 64KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* Externer Quarz
* Real-Time-Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 11 Timer, je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 16 AD-Eingängen
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

'''Der 10-Polige JTAG-Stecker:'''

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

'''Installation für STM32'''

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

* ST Firmware:
http://www.st.com >> Auswahl CPU STM32F103xxx >> "Firmware" "STM32F10x_StdPeriph_Lib"
http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
In dem ZIP ist ein ZIP mit der Firmware "\Archive\um0427.zip"
Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.2.0\

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

'''Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):'''
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

== Bezugsquellen ==

=== Controller ===
Versandhäuser für Privatpersonen:
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html

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

=== Evaluation-Boards ===
* http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14
* http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3
* http://www.sander-electronic.de/es0028.html
* http://www.mikrocontroller.net/articles/MP32F103-Stick:_Ein_Mini-Mikrocontroller-Board_mit_USB_und_bis_zu_4MB_Datenspeicher

STM32

2010-04-08T08:48:55Z

80.72.130.218: /* Bezugsquellen */

'''
== STM32 ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 64KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* Externer Quarz
* Real-Time-Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 11 Timer, je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 16 AD-Eingängen
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

'''Der 10-Polige JTAG-Stecker:'''

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

'''Installation für STM32'''

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

* ST Firmware:
http://www.st.com >> Auswahl CPU STM32F103xxx >> "Firmware" "STM32F10x_StdPeriph_Lib"
http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
In dem ZIP ist ein ZIP mit der Firmware "\Archive\um0427.zip"
Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.2.0\

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

'''Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):'''
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

== Bezugsquellen ==

=== Controller ===
Versandhäuser für Privatpersonen:
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html

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

=== Evaluation-Boards ===
* http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14
* http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3
* http://www.sander-electronic.de/es0028.html

STM32

2010-04-08T08:47:13Z

80.72.130.218: /* Evaluation-Boards: */

'''
== STM32 ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 64KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* Externer Quarz
* Real-Time-Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 11 Timer, je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 16 AD-Eingängen
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

'''Der 10-Polige JTAG-Stecker:'''

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

'''Installation für STM32'''

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

* ST Firmware:
http://www.st.com >> Auswahl CPU STM32F103xxx >> "Firmware" "STM32F10x_StdPeriph_Lib"
http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
In dem ZIP ist ein ZIP mit der Firmware "\Archive\um0427.zip"
Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.2.0\

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

'''Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):'''
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

== Bezugsquellen ==
Versandhäuser für Privatpersonen:
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html

Gewerblich lieferen natürlich viele wie Farnell, Digikey usw.

STM32

2010-04-08T08:45:49Z

80.72.130.218:

'''
== STM32 ==
'''

Der STM32 ist ein Mikrocontroller von ST ([www.st.com]http://www.st.com/mcu/inchtml-pages-stm32.html) mit einer 32-Bit ARM Cortex-M3 CPU. (http://www.arm.com/products/processors/cortex-m/index.php). Diese Architektur ist speziell für den Einsatz in Microcontrollern neu entwickelt, und löst damit die bisherigen ARM7 basierten Controller weitestgehend ab.
Den STM32 gibt es von ST in unzähligen Varianten mit variabler Peripherie und verschiedenen Gehäusegrössen und -formen.
Durch u.a. die geringe benötigte Chipfläche des Core ist es ST möglich, eine 32 Bit-CPU für weniger als 1 EUR an zu bieten.
* Cortex-M3 Kern
* 16KB ... 1MB Flash-ROM und bis zu 64KB SRAM
* Gehäuse 36 ... 144 Pins als QFN, LQFP und BGA
* Derzeit bis 72MHz, Modelle bis 120MHz sind angekündigt
* Externes Businterface
* Spannungsbereich 2,0 ... 3,6V
* Bis zu 112 IOs, viele davon 5V-tolerant
* Interner kalibrierter RC-Oszillator mit 8MHz
* Externer Quarz
* Real-Time-Clock mit eigenem Quarz und separater Stromversorgung
* Bis zu 11 Timer, je Timer bis zu 4 IC/OC/PWM Ausgänge. Davon 2x Motion Control Timer
* Systick Counter
* Bis zu 3 12-Bit AD-Wandler mit insgesamt 16 AD-Eingängen
* Bis zu 2 DMA Controller mit jeweils bis zu 12 Kanälen
* JTAG und SWD (Single Wire Debug) Interface
* Bis zu 2x I²C
* Bis zu 5x USART mit LIN, IrDA und Modem Control
* Bis zu 2x CAN
* USB 2.0 Full Speed
* SDIO Interface (z.B. SD-Card Reader)
* Ethernet
* ... (Siehe Datenblätter)

'''

== Struktur der Dokumentation: ==
'''

Als Beispiel der Dokumentation zeige ich mal stellvertretend den STM32F103RC. Die Seite von ST: http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
Beinhaltet alle nötigen Informationen/Dateien/Dokumente passend zu diesem Prozessor.

Diese Dokumente von ST beschreiben den Controller:

* Datasheet "STM32F103xC/D/E" oder einer anderen Modellreihe
* Reference Manual "RM0008"
* Cortex-M3 Programming Manual "PM0056"
* Flash Programming Reference "PM0042"

Im Datasheet sind die speziellen Eigenschaften eines bestimmten Modells bzw. einer Modellreihe beschrieben und die exakten Daten und Pinouts aufgeführt. Die Peripheriemodule werden nur aufgeführt, nicht detailliert beschrieben. In der Referenz ist der gesamte Controller mit Peripheriemodulen im Detail beschrieben, gültig für alle STM32 Prozessoren. Details zum Prozessor selbst und den nicht STM32-spezifischen mit dem Cortex-M3 Core assoziierten Modulen wie dem Interrupt-Controller und dem Systick-Timer findet man jedoch nicht dort, sondern im Cortex-M3 Manual. Wer nicht die ST Firmware-Library verwendet, der benötigt zusätzlich das Flash Programming Manual für die Betriebsart des Flash-ROMs, d.h. die frequenzabhängige Konfiguration der Waitstates.

Hinzu kommen optionale Dokumente von ARM, die den Cortex-M3 Kern beschreiben.
Siehe z.B. hier: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.set.cortexm/index.html. Hier gibt es den Opcode wenn man ihn in Assembler programmieren möchte: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.ddi0406b/index.html

Zusätzlich sollten auch die Errata Sheets beachtet werden.

Empfohlen sei auch die Appnote: "STM32F10xxx hardware development: getting started" http://www.st.com/stonline/products/literature/an/13675.pdf

'''

== FW-Lib: ==
'''

ST bietet eine umfangreiche FW-LIB Bibliothek. Es ist eine einzige Bibliothek für alle STM32 Derivate. Das ist der große Vorteil von ST. Einmal programmieren und in allen STM32 verwendbar. Alle Funktionen sind gekapselt in einfache Strukturen und Funktionsaufrufe. Somit muss man sich nicht selbst um die Peripherieregister kümmern.
Die FW-Lib kann ebenfalls von der STM32 Seite kostenlos geladen werden:

* Firmware "STM32F10x_StdPeriph_Lib"

In dem Archiv ist die FW-LIB, zu jeder Peripherie gibt es bis zu 12 Demos und eine Beschreibung als CHM Datei "stm32f10x_stdperiph_lib_um.chm"

'''

== CMSIS: ==
'''

Parallel zur Firmware-Library gibt es für die "Selbermacher" die CMSIS, die einen Teil der HW und den Core Support abdeckt.
Im Rahmen des CMSIS Standard (www.onARM.com) wurden die Headerfiles standardisiert, der Zugriff auf die Register erfolgt per '''Peripheral->Register'''. Weiterhin existieren eine Zahl von Helferfunktionen für den NVIC, als auch eine SystemInit - Funktion, welche sich um die PLL kümmert.

== Debug-Interface: ==
'''
Als Debug Interface stehen zwei Varianten zur Auswahl:
* JTAG
* SWD (Single Wire Debug)

Für JTAG sind 6 Steuerleitungen nötig, für SWD 2 (zzgl GND/3,3V).
Das SWD Interface verfügt ausserdem über eine weitere Leitung, SWO. Über diesen Kanal kann ein vereinfachtes Trace des Core ermöglicht, sowie printf-like Daten über den ITM Channel 0 geschickt und im Debugger ausgegeben werden.

Die Coresight-Debug-Architektur ermöglicht ein non-invasive debugging, d.h. es können während des Betriebes ohne Beeinflussung des Prozessors Daten vom Speicher gelesen und in selbigen geschrieben werden.

'''Der 10-Polige JTAG-Stecker:'''

Ich habe einen 10 Poligen Debug-Stecker entworfen, der alle Varianten sowie einen UART Anschluss enthält:

[[bild:jtag-debug-port10.png]]

'''Die Funktionen:'''
* JTAG
* SWD
* Debug-UART-Anschluss (verbunden mit einem freien UART vom STM32) (alternativ ein MAX232 Chip dazwischen schalten)
* Weniger Platzbedarf auf der Platine (Standard-JTAG 20 Polig)
* Über 4-Poligen Würfel kann der UART benutzt werden (Pin 7/8/9/10)
* Es kann ein Jumper gesteckt werden für eine Option (Pin 7/8) ohne dass es sich mit dem RS232 Chip beißt (sofern er eingebaut wurde)
* Über einen 5-Poligen einreihigen Stecker kann SWD (SingleWireDebug) verwendet werden (Pin 1/3/5/7/9)
* den ganzen Stecker braucht es nur, wenn man den herkömlichen JTAG nutzen möchte.
* Kurzschlussschutz, da GND und +3V3 nicht gegenüber liegen

In all meinen Projekten verwende ich nur noch diese Anordnung, denn sie ist einfach praktisch. Alles drauf und die Pins sind perfekt angeordnet für jede Art der Anwendung.

'''

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

* Interrupt-Controller jetzt Teil des Prozessors (als Core Peripheral), die Vector Table ist jetzt eine echte Vector Tabelle (keine jmps o.ä. 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. 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.
* Thumb-2 Befehlssatz wird schneller ausgeführt

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

* Flexiblere Gehäuseformen mit mehr Peripherie bei kleinen Gehäusen
* Genauerer ADC, insbesondere gegenüber LPC1300
* Flexiblere Varianten der Peripherie >> bei weniger einen deutlichen Preisvorteil
* ab 0,85 EUR (Stand 2010)
'''Nachteil gegenüber LPC1700:'''
* Nur 72 MHz statt 100 MHz Taktfrequenz
'''Vorteile gegenüber anderen "Kleinen" wie z.B. PIC, Atmel usw.'''
* nahezu gleicher Preis bei Hobby Anwendungen
* 32 Bit ohne Umwege in Assembler rechenbar
* bessere Peripherie
* ... und weitere 1000 Punkte ...

'''Nachteil für Hoppy-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.

'''

== Software/Programmierung: ==
'''
Als Programmieroberfläche kann eine kostenlose Struktur verwendet werden (wie meinen?):

* Eclipse
* Coudesourcery Light
* OpenOCD
* Yagarto Tools
* Eclipse Plugin "GDB Hardware Debugging"

Folgende Umgebungen sind als Demoversion (32k Codesize) verfügbar, idR sind dutzende von Examples dabei:

* Keil µVision (www.keil.com)
* IAR (www.iar.com)

Programmieradapter
* J-Link / J-Trace Cortex-M3 (www.segger.com), als NonComercial für ca. 60,- zu haben, läuft in µVision, IAR, gdb
* z.B. OpenOCD ARM-USB-OCD (nicht kostenlos)
* Keil ULINK2, ULINK pro

'''Installation für STM32'''

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

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

* CodeSourcery:
http://www.codesourcery.com/ >> Products>Sourcery G++>Editions>Lite >> Try Now
http://www.codesourcery.com/downloads/public/public/gnu_toolchain/arm-none-eabi/arm-2009q3-68-arm-none-eabi.exe
Installieren, Auswahl Verzeichnis "C:\WinARM\CodeSourcery"

* OpenOCD, kompilliert von Martin-Thomas:
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/winarmtests/
Die letzte Version ist "dont_download_this_OpenOCD_package_V0_3_1_mthomas.zip"
Die aktuellste ist im Sourceforge als Quelldateien.

* ST Firmware:
http://www.st.com >> Auswahl CPU STM32F103xxx >> "Firmware" "STM32F10x_StdPeriph_Lib"
http://www.st.com/mcu/devicedocs-STM32F103RC-110.html
In dem ZIP ist ein ZIP mit der Firmware "\Archive\um0427.zip"
Das ZIP "stm32f10x_stdperiph_lib.zip" Entpacken nach "C:\WinARM\examples\stm32_FW3.2.0\

Eclipse:
Help >> Install New Software... >> http://download.eclipse.org/tools/cdt/releases/galileo
"Eclipse C/C++ Development Tools" + "Eclipse C/C++ GDB Hardware Debugging" installieren

'''Installation für STM32 auf einem zweiten Rechner (Eclipse/GCC Installation):'''
* Kopieren des Verzeichnisses C:\WinARM\
* Die PATH-Variable in der Systemsteuerung mit den C:\WinARM.... Verzeichnissen nachführen
* Fertig.
'''

== Evaluation-Boards: ==
'''
* http://shop.embedded-projects.net/index.php?module=artikel&action=gruppe&id=14
* http://www.watterott.com/de/Boards-Kits/ARM/ARM-Cortex-M3
* http://www.sander-electronic.de/es0028.html

'''

== Demo-Projekte: ==
'''
Martin Thomas hat ein umfangreiches Projekt erstellt, in der die Eclipse Einstellungen enthalten sind:

"ChaN's FAT-Module with STM32 SPI"
http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/index.html

== Bezugsquellen ==
Versandhäuser für Privatpersonen:
* TME.eu: http://www.tme.eu/de/katalog/index.phtml#cleanParameters%3D1%26search%3DSTM32F10%26bf_szukaj%3D+
* Darisus: http://darisusgmbh.de/shop/index.php?cat=c2692_ARM-Cortex.html
* Sander: http://www.sander-electronic.de/be00069.html

Gewerblich lieferen natürlich viele wie Farnell, Digikey usw.