Mikrocontroller.net - Benutzerbeiträge [de]

MMC- und SD-Karten

2010-10-23T09:32:36Z

194.208.80.202: /* Bibliotheken zur Ansteuerung */

MMC- und SD-Speicherkarten lassen sich im [[SPI]]-Modus relativ einfach mit einem Mikrocontroller ansteuern. Prinzipiell git es zwischen SD-Card und MMC nicht viele Unterschiede, allerdings sind SD-Karten weiter verbreitet, in der Regel schneller als MMCs, und haben eine besser implementiertes SPI-Interface. Es existieren diverse Varianten (miniSD, microSD) die zur normalen SD-Card kompatibel sind.

Die Karte liest das anliegende Datenbit mit der steigenden Taktflanke ein, als SPI-Modi eignen sich somit Mode 0 (CPOL=0, CPHA=0) und Mode 3 (CPOL=1, CPHA=1) (siehe auch [[Serial Peripheral Interface]]). Bei MMCs ist der SPI-Modus nicht genau spezifiziert, somit kommt es durchaus mal vor dass der SPI-Modus je nach Karte unterschiedlich gewählt werden muss, oder dass die Karte überhaupt nicht zuverlässig funktioniert (siehe [http://www.mikrocontroller.net/forum/read-1-343528.html Beitrag im Forum]).

== DOs und DON'Ts bei der Ansteuerung ==

* '''Lasst euch nicht verrückt machen''' wenn es einfach nicht funktioniert, sondern probiert zu allererst mal eine SD-Karte eines anderen Herstellers aus. Die MMC-Implementierung für AVR von Elm Chan z. B. funktioniert mit SanDisk problemlos hat aber mit Platinum Karten ein Problem.
* Taktfrequenz bei der Initialisierung nicht höher als 400kHz
* Ein Pullup-Widerstand am Ausgang der MMC/SD Karte (DO) ist für eine saubere Initialisierung per SPI notwendig! [http://www.mikrocontroller.net/topic/112421#1001693 (Thread mit Erklärung dazu)]
* Saubere Versorgung: Kein Dioden-Pfusch, mit dem eine vorhandene 5V Versorgung mittels in Reihe geschalteter Dioden auf irgendwas im Bereich 3V "geregelt" wird. Stattdessen einen guten 3,3V-Regler verwenden. Die Karte mag es nicht, wenn mehr als 60mV Ripple auf Vcc ist. LM317 oder LM1117-ADC/-3.3 mit entspechenden Kondensatoren reicht zumindest bei Basteleien allemal.
* Sauberer Anschluss der Digitalschnittstelle: Spannungsteiler "verschleifen" die Signale bei hohen Frequenzen und die Übertragungsrate muss dann begrenzt werden. Also entweder ein [http://www.mikrocontroller.net/articles/Pegelwandler Pegelwandler] oder gleich an ein 3,3V I/O anschließen.
* Ein Pullup-Widerstand an der Select-Leitung (/CS) schadet nicht und stellt sicher, dass die Karte erst mit Absicht selektiert wird.
* Nachdem die Karte deselektiert wurde (/CS auf high), die Taktleitung noch einige Male pulsen, damit die Karte DO hochohmig/tri-state schaltet (vgl. Chans Erläuterungen).
* Die Karten verfügen weder über einen Reset- noch einen Sleep-Anschluss. Moderne Karten reduzieren bei Nichtbenutzung ihren Stromverbrauch, einen vollständigen Reset kann man jedoch nicht per Software auslösen. Daher sollten die Karten per P-Channel-FET oder Spannungsregler/-wandler mit Enable-Funktion so angeschlossen werden, dass über Versorgung an/aus ein (Power-On-)Reset ausgelöst werden kann. Dabei darauf achten, dass vorhandene Pull-Up-Widerstände bei abgeschalteter Versorgung ebenfalls deaktiviert werden (vgl. z. B. Schaltplan für den Anschluss von SD-Card/MMC per SPI an AVR in Chans Beispielen. Link unten).
* Guter Kontakt im Steckplatz, sehr gut eignen sich mit der Zange verbogene Stiftleisten, oft sieht es aus als ob es "passt", aber es gibt doch keinen Kontakt, daher bei Fehlern: Immer Durchmessen! Auch zu erwähnen wären da alte ISA-Bus Buchsen, die auf jedem alten PC Mainboard drauf sind. Um sicher zu gehen, dass der Kontakt wirklich gut ist, sollte man aber trotzdem SD-Slots benutzen. Diese bekommt man u.a. bei CSD (günstig), Reichelt (teuer) oder aus alten Kartenlesern.
* Guter Kontakt #2: Was sich im übrigen auch sehr gut eignet sind Adapter von MiniSD auf normales SD-Format, um dann MiniSD zu benutzen. Wenn man eine Stiftleiste im 2.54mm-Format oder Lötnägel im selben Format auf der Platine hat, kann man daran wunderbar den SD-Kartenadapter anlöten. Das ist mechanisch recht stabil. Ein kleines Manko ist allerdings, daß dann eine Gold-Lötzinn-Legierung durch die vergoldeten Kontakte entsteht und das soll ja dem Lötzinn langfristig nicht sehr zuträglich sein. Aber für's Hobby funktioniert das wunderbar.

{| border="0"
|-
||[[Bild:SD Steck Stift.jpg]] 
(Liefere Bild in besserer Qualität nach!)
|}

== Bibliotheken zur Ansteuerung ==

* [http://elm-chan.org/fsw/ff/00index_e.html ELM ChaN FatFs] FAT(12,16,32)-Dateisystem. Klein und übersichtlich, hochoptimiert, frei auch für kommerzielle Anwendung. Beispiele für AVR, H8, LPC2k mit MCI u.a. enthalten ("samples"), neuere Versionen mit LFN-Unterstützung. Beispiel für AT91SAM7 inkl. DMA im Projekt [[ARM MP3/AAC Player]]. (siehe auch [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/ M. Thomas' ARM+SD/MMC Seite])

* [http://elm-chan.org/fsw/ff/00index_p.html ELM ChaN Petit FatFS] FAT(12,16,32)-Dateisystem. Sehr klein. Beispiele für AVR.

* [http://sourceforge.net/projects/efsl EFSL] FAT16/32-Dateisystem, unterstützt Partitionen und Superfloppys, Beispielcode für AVR, LPC2000 und AT91SAM7 enthalten (siehe auch [http://www.siwawi.arubi.uni-kl.de/avr_projects/arm_projects/arm_memcards/ M. Thomas' ARM+SD/MMC Seite])

* [http://www.holger-klabunde.de/avr/avrboard.htm#cf Holger Klabundes FAT16/32] mit Beispielen für AVR MMC/SD und CF, LPC2k mit SPI

* libfat aus dem [http://sourceforge.net/projects/devkitpro devkitpro-Projekt] u.a. LFN-Unterstützung.

* [http://www.mikro-control.de/Joomla/index.php?option=com_content&task=view&id=18&Itemid=30 SD-Logger] - FAT 16, für den privaten Einsatz kostenfrei

* [http://www.mikrocontroller.net/forum/read-4-125350.html MMC-Ansteuerung mit FAT16 von Ulrich Radig]

* [http://www.zws.com/products/dosfs/index.html DOSFS Free FAT12/FAT16/FAT32 Filesystem] "DOSFS is a free FAT-compatible filesystem intended for fairly low-end embedded applications. Intended target systems would be in the ballpark of 1K RAM, 4K ROM or more".

* [http://www.mikrocontroller.net/topic/48481 MMC/SD-Karte mit FAT16 an AVR] von Roland Riegel

* [ftp://ftp.circuitcellar.com/pub/Circuit_Cellar/2005/176/Sham176.zip Circuit Cellar FAT16 MMC/SD] mit MMC/SD Hardwaretreiber für MSP430

* [http://www.analog.com "Implementing FAT32 File Systems on ADSP-BF533 Blackfin Processors"] Application Note und Code von ADI

* [http://www.atmel.com/dyn/products/tools.asp?family_id=682 FAT-Code in Atmel's AVR32 UC3 Software-Library]

* [http://www.mikrocontroller.net/articles/FAT32 AVR FAT16/32] Bibliothek mit Wiki. Unterstützt LFN und Ordner Rekursiv löschen. SVN für neuste Version.

* [http://www.embedded-os.de/index.html?pcfat_port.htm pC/FAT driver] "using SPI for sector read/write to MMC/MMCplus/HD-MMC/M-Bridge/SD/SDHC-cards on different platforms"

* [http://www.dharmanitech.com/2009/01/sd-card-interfacing-with-atmega8-fat32.html SD Card Interfacing with ATmega8] (FAT32 implementation) by CC Dharmani

* [[AVR FAT32]]

== Allgemeine Informationen ==

* [http://www.digitalspirit.org/file/index.php/obj/docs/sd/ Datenblätter] ( [http://www.digitalspirit.org/file/index.php/obj-download/docs/sd/ProductManualSDCardv2.2final.pdf SD Card Product Manual 2.2] )

* [http://elm-chan.org/docs/mmc/mmc_e.html ELM ChaN - How to Use an MMC]

* [http://elm-chan.org/fsw/ff/00index_e.html ELM ChaN - MMC/SD Benchmarks]

* [http://www.mikrocontroller.net/forum/list-1-1.html?filter=MMC*+SD Beiträge zum Thema MMC/SD im Forum (ca. 200 Threads)]

* [http://www.shop.display3000.com/pi8/pi14/pd102.html Weiter unten im Text (runterscrollen) gibt es interessante Oszi-Bilder zu den oft genannten Spannungsteilern oder Transistorlösungen als Pegelwandler]

* [http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=2680&dDocName=en547784 Microchip Memory Disk Drive System mit FAT32 und SDHC Unterstützung]

* [http://www.ifas.htwk-leipzig.de/easytoweb/download/D&E_11_2006_Anbindung_von_SD-Karten.pdf Gute Beschreibung der SDIO-Architektur und wie man eine SD-Karte mit ARM bzw. AVR benutzt]

== Bauteile ==

* [http://www.instructables.com/id/EZD6Q18LYGES1762SJ/ DIY SD-Card Fassung aus einem alten Floppy Kabel]

* [http://www.watterott.com/index.php?page=search&page_action=query&desc=on&sdesc=on&keywords=multicomp&x=0&y=0 Halter für SD-Karten] (Shop www.watterott.com)

== Projekte ==

* [http://retromaster.wordpress.com/ufe/ Ultimate Floppy Emulator] von Retromaster (PIC32 @ 80 Mhz, 16 Mb SDRAM)

[[Category:Bauteile]]
[[Category:Datenübertragung]]
[[Kategorie:Speicher und Dateisysteme]]

FAQ

2010-05-01T20:44:18Z

194.208.80.202: /* Wie funktioniert String-Verarbeitung in C? */

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.

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, so er nicht sowieso schon ein double Wert ist, ebenfalls zu einem double zu machen und die Operation als Gleitkommaoperation durchzuführen.

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.

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 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.
* 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.

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

Dies vereinbart MeineFunktionen als ein Array von Funktionszeigern, wobei jeder Funktionszeiger auf eine Funktion vom Typ void-void zeigt.

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

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

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

struct MenuEntry {
char Text[20];
VoidFnct Function;
};
</c>

Ein Menü ist dann einfach ein Array aus derartigen Strukturelementen

<c>

void HandleEdit()
{
}

void HandleCopy()
{
}

void HandlePaste()
{
}

struct MenuEntry MainMenu[] = {
{ "Edit", HandleEdit },
{ "Copy", HandleCopy },
{ "Paste", HandlePaste }
};

#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
Menu[Auswahl].Function();
}
}

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, daß 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]]