RN-Wissen.de - Benutzerbeiträge [de]

GPS

2009-12-13T13:51:29Z

RobotProgger:

{{Ausbauwunsch|Konkrete Codebeispiele}}

===Einführung===
[[Bild:gpsprinzip.gif|right]]
GPS, das ''Global Positioning System'' ist die Grundlage für alle modernen Navigations - und Ortungssysteme im Bereich der Land- ,Luft, - und Seenavigation.

Es ist ein satellitengestützter Mobilfunkdienst, der in den 70er Jahren vom amerikanischen Verteidigungsministerium für militärische Zwecke aufgebaut wurde und auch heute noch unterhalten wird. Die Leitzentrale "Master Control Station" für das GPS befindet sich in der Schriever Air Force Base (ehemals Falcon AFB), in der Nähe von Colorado Springs.

Das System besteht aus 24 Satelliten, die auf sechs kreisförmigen Bahnen im 24 Stunden Rhythmus in einer Entfernung von rund 20 000km um die Erde kreisen.

Diese Anordnung stellt sicher, daß immer mindestens das Signal von vier Satelliten erfaßt werden kann. Dies stellt die mögliche Positionsberechnung mittels Entfernungsmessung ('''mind. vier Satelliten''') sicher. Hierbei können über die Differenzen der Signallaufzeiten die Differenzen der Entfernungen zu den Satelliten berechnet werden. Da die Postitionen der Satteliten bekannt ist, kann damit über eine geometrische Berechnung die Position bestimmt werden. Nur wenn die Höhe über dem Meeresspiegel bekannt ist (oder geschätzt wird) reichen drei Satelliten.

Jeder Satellit sendet 50 mal pro Sekunde drei verschiedene Signale:
Den Pseude-Zufalls-Code (zur Positionsbestimmung), das Almanach-Signal (Satellitenstandort) und das Zeitkorrektur-Signal (Zeitbestimmung).

Der Pseudo-Zufalls-Code wird auf zwei unterschiedlichen Frequenzen ausgesendet. Der eine ist für die militärische Nutzung, der zweite für die zivile Nutzung vorgesehen.
Für die zivile Nutzung wurde das Signal bis Mai 2000 mit einem künstlichen Timing-Fehler versehen, der die Genauigkeit der Positionsbestimmung auf ca. 100 m beschränkte. Am 2.Mai 2000 um 5:05 Uhr wurde die Signalverschleierung - selective availability - kurz SA" dann abgeschaltet.

Mit mathematischen Funktionen im Empfängerteil von hochwertigen GPS Receivern konnte der Timingfehler in den Jahren bis 2000 jedoch auch korrigiert werden, so daß Genauigkeiten von 20 bis 30 Metern machbar waren.
Heute ist die Genauigkeit der Positionsbestimmung durch die Aufhebung der `Signalverschleierung(SA)` für die zivile Nutzung mit 5-25 Metern Abweichung , je nach verwendetem GPS-Empfänger, für die einfache zivile Nutzung mehr als ausreichend. Je nach Stellung der Satelliten am Himmel ist die Qualität des GPS-Signals jedoch auch stark zeit- und ortsabhängig.

Für die Güte der Satellitengeometrie wird der DOP-Wert angegeben. H-DOP für den horizontalen Wert und V-DOP für den vertikalen Wert(dieser ist jedoch im Bereich Strassennavigation nicht weiter von Bedeutung. So sind HDOP-Werte unter 4 sehr gut, über 8 jedoch schlecht. Die HDOP Werte werden schlechter, wenn sich die empfangenen Satelliten hoch am Himmel befinden. VDOP Werte hingegen sind eher schlechter, wenn sich die Satelliten sehr nahe am Horizont befinden. Die HDOP und VDOP Werte werden im NMEA-Satz $GPGSA ausgegeben.

GPS-Signale werden in einem sehr hohen Frequenzbereich (~ 1,5 GHZ ) ausgesendet, um die weiten Distanzen problemlos zurückzulegen. Nachteil der hohen Frequenzen ist die leichte Abschirmbarkeit der Signale bei fehlender Sichtverbindung zum Himmel z.B. in Gebäuden. Zur Nutzung von GPS-Signalen in Gebäuden gibt es mittlerweile Spezialantennen die einen Empfang in Gebäuden ermöglichen. Deshalb sollte beim Aufbau eigener präziser GPS-Anwendungen grundsätzlich vor allem auf eine hohe Qualität der Antenne geachtet werden("Jedes GPS-Anwendung ist so gut wie seine Antenne" - Joe Wynders/GPS-Systems for High Precision/2004).
[[Bild:gpsmodul.jpg|thumb|Ein handelsübliches GPS Modul]]
Um das GPS Signal für die Navigation verwenden zu können, benötigt man das passende Kartenmaterial, das in digitaler vektorisierter Form vorliegen muß. Die Vektorform wird benötigt, um mittels mathematischer Funktionen eine Routenberechnung durchführen zu können.

Die Positionmarkierungen des Kartenmaterials werden so mit dem empfangenen Signal abgeglichen und die Route zu einem definierten Zielpunkt kann berechnet werden.

Zukünftig wird vor allem [[GALILEO]], ein GPS-System der europäischen Gemeinschaft, das mittlerweile veraltete GPS-System der Amerikaner revolutionieren und der bestehenden Abhängigkeit der EU vorbeugen. Die Inbetriebnahme ist für 2008 geplant.

GPS-Module sind inzwischen auch recht preiswert mit RS232 Schnittstelle für Mikrocontroller erhältlich.

==Wieviel Satelliten sind notwendig?==
Es reichen drei Satelliten, damit daraus die genaue Position und Höhe bestimmt werden kann. Dies setzt jedoch eine genaue Zeitvorgabe voraus. In der Praxis haben aber die Mehrzahl der GPS-Empfänger keine Uhr, die genau genug ist, um daraus die Laufzeiten korrekt berechnen zu können. Deshalb wird meistens das Signal eines vierten Satelliten herangezogen um die Position möglichst genau zu bestimmen.
3 Satelliten reichen jedoch stets aus um die genaue 2D-Position zu ermitteln.

'''Aber unsere Erde ist dreidimensional, braucht man dann nicht doch vier Satelliten?'''

Theoretisch ja, in der Praxis nein! Man kann in der Praxis auch mit drei Satelliten eine Ortsbestimmung erhalten, aber wie erwähnt nur eine zweidimensionale Position. Zweidimensional bedeutet, dass sich die zu bestimmende Position auf der Erdoberfläche befinden muss. Der für die Berechnung notwendige vierte Satellit wäre der Erdmittelpunkt und die zu diesem Satelliten bestimmte Entfernung wäre die Entfernung der Erdoberfläche vom Erdmittelpunkt (6360 km). Somit hat man wieder vier gemessene Pseudoentfernungen aus denen die tatsächliche Position bestimmt wird. Aber eben mit der Einschränkung, dass der Empfänger immer davon ausgeht, dass man sich direkt auf der Erdoberfläche befindet. Erdoberfläche meint in diesem Fall das Erdgeoid, also Meereshöhe. Ist das nicht der Fall (ist man z.B. auf einem Berg), kommt es zu Fehlern, also Ungenauigkeiten bei der Bestimmung, da die Laufzeiten von den Satellitensignalen nicht stimmen.

==Typen von GPS-Satelliten==
Man unterscheidet fünf Klassen von GPS-Satelliten: '''Block I, Block II, Block IIA, Block IIF und Block IIR-Satelliten.'''

===Block I===
Zwischen 1978 und 1985 wurden von Kalifornien elf Block I-Satelliten (Masse 845 kg) gestartet, von denen heute keiner mehr in Betrieb ist, von denen jedoch einige, obwohl nur für 4,5 Jahre konzipiert, mehr als 10 Jahre in Betrieb waren.

===Block II===
Die Konstellation der Block II-Satelliten unterscheidet sich durch die Inklination der Bahnebenen von 55 von der der Block I-Satelliten (63 ). Des weiteren waren sämtliche Signale der Block I-Satelliten zivilen Nutzern zugänglich, die der Block II-Satelliten jedoch nur eingeschränkt.
Der erste Block II-Satellit kostete an die $ 50 Mio., wog mehr als 1.500 kg und wurde 1989 von Cape Canaveral gestartet. Block II-Satelliten sind für 7,5 Jahre ausgelegt und erreichen eine durchschnittliche Betriebsdauer von 6 Jahren.

===Block IIA===
Der erste Block IIA-Satellit (A : ''advanced'') wurde 1990 in die Umlaufbahn geschossen.

===Block IIR===
Die Block IIR-Satelliten (R.''replacement'') mit einer angestrebten Betriebsdauer von 10 Jahren befinden sich noch in Entwicklung (1992) und werden vorraussichtlich Wasserstoff-Maser an Bord haben. Diese Atomuhren sind mindestens um eine Größenordnung genauer als die an Bord der Block II-Satelliten befindlichen Atomuhren. Satelliten vom Typ Block IIR wiegen mehr als 2.000 kg, kosten jedoch nur die Hälfte wie solche vom Typ II. Block IIR-Satelliten sollen mit Hilfe eines Space Shuttle in die Umlaufbahn gebracht werden, wobei jeder Shuttle bis zu drei Satelliten in die Umlaufbahn bringen könnte, was eine schnelle Vervollständigung der Satellitenkonstellation ermöglicht.

===Block IIF===
Die nächste Generation von Satelliten, die vom Typ IIF (F: ''follow on'') werden zwischen 2000 und 2010 gestartet werden, ausgelegt für einen Betrieb von mindestens 10 Jahren.

==NMEA-0183 Datenprotokoll==
Um GPS Daten an Endgeräte wie Pocket PC´s, Microcontroller weiterzugeben, bedient man sich vorwiegend des sogenannten NMEA-Protokolles.
Mit Hilfe der weitestgehend standardisierten NMEA-Daten gelingt es sehr leicht, die Daten praktisch jedes GPS-Geräts mit einem Navigations- und Kartenprogramm auf dem PC, Laptop oder Handheld zu verwenden. Sogenannte GPS-Mäuse (GPS-Empfänger ohne Display nur mit serieller Schnittstelle) kommunizieren ausschliesslich auf diese Art mit Ihrer Aussenwelt. In der Seefahrt werden Kursplotter und ähnliches mit Hilfe von NMEA-Datensätzen mit Positionsdaten versorgt.

NMEA steht für ''National Marine Electronics Association'' (Nationale Vereinigung für Marineelektronik). Diese Vereinigung engagiert sich für die Ausbildung und den Fortschritt der Marine-Elektronikindustrie und dem Markt, den diese bedient. Es handelt sich dabei um eine nicht auf Profit ausgelegte Vereinigung von Herstellern, Vertreibern, Ausbildungsinstitutionen und anderen mit Interesse an diesem Markt (frei aus "NMEA News").

===Das Protokoll NMEA-0183===
Die NMEA hat nun unter anderem den Standard NMEA-1083 definiert, um einen Datenaustausch zwischen verschiedenen Geräten aus der Marineelektronik zu ermöglichen. Die NMEA-0180, 0182 und 0183 Standards (die ersten beiden sind nicht mehr von Bedeutung) sehen pro "Netz" ein Sendegerät und diverse Empfangsgeräte vor. Der Sender soll Daten nach dem RS-232-Standard (vom PC als Datenformat der COM-Schnittstellen bekannt) ausgeben. Die Datenrate beträgt 4800 baud (ca. 600 Bytes/Sekunde) und es ist in diesem Standard kein Stecker oder ähnliches definiert. Die Anschlussart bleibt also dem Hersteller überlassen, weswegen alle Geräte unterschiedliche Stecker benötigen.

Die Einschränkung, dass es nur einen Sender geben darf sorgt dafür, dass nicht wild durcheinandergequatscht wird. Sollen die Daten von mehreren Geräten zusammengefasst werden, braucht man mindestens ein Gerät, dass auch als Empfänger arbeitet und alle erhaltenen Daten in einen neues "Netz" wieder kombiniert einspeist.

Die Daten werden im ASCII-Format (American Standard Code for Information Interchange, Amerikanischer Standard Code für Informationsaustausch) übertragen. Dabei sind alle druckbaren Zeichen sowie Carriage-Return (CR, Waagenrücklauf) und Line-Feed (LF, Neue Zeile) erlaubt und die Daten werden in der Form von Sätzen übertragen. Jeder dieser Sätze beginnt mir dem Zeichen "$", einer zwei Zeichen langen Senderkennung, einer drei Zeichen langen Satzkennung und dann folgt eine Reihe von Datensätzen, die mit Kommas unterteilt werden. Schliesslich wird der Satz mit einer optionalen Prüfsumme und einer CR/LF abgeschlossen. Jeder Satz kann inklusive des führenden "$" und den beiden CR/LF bis zu 82 Zeichen enthalten. Ist ein Datenfeld in einem Satz zwar vorgesehen aber nicht verfügbar, so wird er einfach weggelassen, das dazugehörige Komma zur Trennung der Datensätze wird aber ohne Leerzeichen beibehalten. Durch Zählen der Kommas kann ein Empfänger dann aus jeden Satz die entsprechenden Informationen richtig zuordnen.

Die meist optionale Prüfsumme besteht aus einem "*" und zwei Hexadezimalzahlen, die sich durch ein (bitweise) exklusiv-oder (1+1=0, 1+0=1, 0+0=0) aller Zeichen zwischen dem "$" und dem "*" berechnen. Bei manchen Sätzen ist die Prüfsumme notwendig.

Der Standard erlaubt weiterhin einzelnen Herstellern eigene (proprietäre) Satzformate. Diese fangen mit "$P" an, gefolgt von der drei Buchstaben langen Herstellerkennung. Anschliessend folgen die Daten.

Einige gängige Senderkennung sind:

GP GPS Empfänger
LC Loran-C Empfänger (älteres Positionsbestimmungssystem)
OM Omega Navigations Empfänger (altes Radionavigationssystem; ausser Betrieb)
II Integrated Instrumentation (z.B. AutoHelm Seatalk System; Autopiloten)

Die Datensätze der unterschiedlichen Geräte können sehr viele verschiedene Informationen beinhalten, darunter Position, Geschwindigkeit, Richtung, Wassertiefe, Wassertemperatur, Wegpunkte, Windgeschwindigkeit usw.

Nachfolgend sollen beispielhaft die Daten, die ein Garmin etrex Vista ausgibt näher beschrieben werden. Ein praktisches Programm um sich unter anderem NMEA-0183 Daten anzusehen ist Visual-GPS.

Wichtig ist, dass das Datenformat des GPS auf NMEA umgestellt wird (heisst beim Vista genau: NMEA In/NMEA Out). Die Daten werden dann einmal alle zwei Sekunden über die Schnittstelle ausgegeben. Viele PC-Navigations- und Kartenprogramme mit Anschlussmöglichkeit für GPS-Empfänger erwarten im übrigen auch das NMEA-Format zur Navigation. Funktioniert das Zusammenspiel zwischen GPS und einem PC-Programm nicht, sollte man also sowohl kontrollieren, ob man den GPS an der richtigen seriellen Schnittstelle (COM1 oder COM2) angeschlossen hat, als auch überprüfen, ob das Ausgabeformat am GPS auf NMEA eingestellt ist.

Ein kompletter Block Daten sieht dann beispielsweise folgendermassen aus:

$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,E,A*19
$GPRMB,A,9.99,L,,Exit,4726.8323,N,00820.4822,E,29.212,107.2,,V,A*69
$GPGGA,191410,4735.5634,N,00739.3538,E,1,04,4.4,351.5,M,48.0,M,,*45
$GPGSA,A,3,,,,15,17,18,23,,,,,,4.7,4.4,1.5*3F
$GPGSV,2,1,08,02,59,282,00,03,42,287,00,06,16,094,00,15,80,090,48*79
$GPGLL,4735.5634,N,00739.3538,E,191410,A,A*4A
$GPBOD,221.9,T,221.5,M,Exit,*6B
$GPVTG,0.0,T,359.6,M,0.0,N,0.0,K*47
$PGRME,24.7,M,23.5,M,34.1,M*1D
$PGRMZ,1012,f*36
$PGRMM,WGS 84*06
$HCHDG,170.4,,,0.4,E*03
$GPRTE,1,1,c,*37

Wenn die Navigation mit einer Route aktiviert wurde, können noch weitere Sätze hinzukommen, die die Route beschreiben. Interessant ist auch, dass anscheinend je nach leicht Softwareversion unterschiedliche Datensätze ausgegeben werden.

Nachfolgend sind noch einige Datensätze im einzelnen aufgeschlüsselt:
Der GPRMC-Datensatz (RMC = recommended minimum sentence C, empfohlener Minimumdatensatz) ist eine Empfehlung für das Minimum, was ein GPS-Empfänger ausgeben soll.

<pre>
$GPRMC,191410,A,4735.5634,N,00739.3538,E,0.0,0.0,181102,0.4,E,A*19
^ ^ ^ ^ ^ ^ ^ ^ ^ ^
| | | | | | | | | |
| | | | | | | | | Prüfsumme

| | | | | | | | |

| | | | | | | | Modus (A,D,E,N,S)
| | | | | | | |
| | | | | | | magnetische
| | | | | | | Deklination 0.4° E
| | | | | | |
| | | | | | Datum: 18.11.02
| | | | | |
| | | | | wahrer Kurs (ohne Bewegung 0)
| | | | |
| | | | Geschwindigkeit über Grund (Knoten)
| | | |
| | | 007° 39.3538' östliche Länge
| | |
| | 47° 35.5634' nördliche Breite
| |
| Empfängerwarnung, A = Daten OK, V = Warnung
|
Uhrzeit der Positionsbestimmung: 19:14:10 UTC-Zeit

</pre>

Das Datenfeld Modus ist erst in NMEA Version 2.3 eingeführt worden und kann sein: A = Autonom; D = Differentiell; E = geschätzt (Estimated); N = ungültig (Not valid); S = Simulator

Der GPGGA-Datensatz enthält die wichtigsten Informationen zur GPS-Position und Genauigkeit.

<pre>
$GPGGA,191410,4735.5634,N,00739.3538,E,1,04,4.4,351.5,M,48.0,M,,*45
^ ^ ^ ^ ^ ^ ^ ^
| | | | | | | |
| | | | | | | Höhe Geoid minus
| | | | | | | Höhe Ellipsoid (WGS84)
| | | | | | | in Metern (48.0,M)
| | | | | | |
| | | | | | Höhe über Meer (über Geoid)
| | | | | | in Metern (351.5,M)
| | | | | |
| | | | | HDOP (horizontal dilution
| | | | | of precision) Genauigkeit
| | | | |
| | | | Anzahl der erfassten Satelliten
| | | |
| | | Qualität der Messung
| | | (0 = ungültig)
| | | (1 = GPS)
| | | (2 = DGPS)
| | | (6 = geschätzt nur NMEA-0183 2.3)
| | |
| | Längengrad
| |
| Breitengrad
|
Uhrzeit

</pre>

Der GPGSA-Datensatz (SA=satellites active, aktive Satelliten) enthält Informationen über die PRN-Nummern der Satelliten, deren Signale zur Positionsbestimmung verwendet werden.

<pre>
$GPGSA,A,3,,,,15,17,18,23,,,,,,4.7,4.4,1.5*3F
^ ^ ^ ^ ^ ^
| | | | | |
| | | | | VDOP (vertikale Genauigkeit)
| | | | |
| | | | HDOP (horizontale Genauigkeit)
| | | |
| | | PDOP (Genauigkeit)
| | |
| | PRN-Nummern von maximal 12 Satelliten
| |
| Art der Positionsbestimmung (3 = 3D-fix)
| (2 = 2D-fix)
| (1 = kein Fix)
|
Auto-Auswahl 2D oder 3D Bestimmung

</pre>

Der GPGSV-Datensatz (SV=satellites in view, sichtbare Satelliten) enthält Informationen über Satelliten, die zur Zeit möglicherweise empfangen werden können und Informationen zu deren Position, Signalstärke usw. Da pro Satz nur die Informationen von vier Satelliten übertragen werden können (Beschränkung auf 82 Zeichen), kann es bis zu drei solche Datensätze geben.

$GPGSV,2,1,08,02,59,282,00,03,42,287,00,06,16,094,00,15,80,090,48*79

Der GPGLL-Datensatz ist ein Überbleibsel aus der Zeit, als es nur LORAN-C als Navigationssystem gab und enthält die geographische Position. Das GPS-Gerät emuliert sozusagen den LORAN-C Empfänger.

$GPGLL,4735.5634,N,00739.3538,E,191410,A,A*4A

Der GPBOD-Datensatz gibt Informationen zur Richtung vom Startpunk zum Zielpunkt an. Der Kurs wird als wahrer (T=true) und magnetischer (M=magnetic) Kurs zum benannten Zielpunkt (hier 'Exit', da keiner angegeben ist) ausgegeben.

$GPBOD,221.9,T,221.5,M,Exit,*6B

Der GPVTG-Datensatz enthält Daten zur Bewegungsgeschwindigkeit und Richtung.

<pre>
$GPVTG,0.0,T,359.6,M,0.0,N,0.0,K*47
^ ^ ^ ^
| | | |
| | | Geschwindigkeit über Grund in km/h (K)
| | |
| | Geschwindigkeit über Grund in Knoten (N)
| |
| Kurs (magnetisch, M)
|
Kurs (wahr, T)
</pre>

Die folgenden drei Datensätze sind Garmin-eigene Datensätze, was die Kürzel P (proprietary) und GRM (Garmin).

Der PGRME-Datensatz enthält den geschätzen Fehler der horizontalen und vertikalen Position. Die Angaben sind jeweils in Meter. Der erste Wert ist der horizontale, der zweite der vertikale und der dritte ein sphärischer Fehler (Kugelradius einer "Fehlerkugel").

$PGRME,24.7,M,23.5,M,34.1,M*1D

Der PGRMZ-Datensatz enthält die Höhe in Fuss.

$PGRMZ,1012,f*36

Der PGRMM-Datensatz enthält das verwendete horizontale Datum. Zu beachten ist, dass die Positionsangaben aus den Navigationsdatensätzen sich auf das hier angegebene Datum beziehen.

$PGRMM,WGS 84*06

Der HCHDG-Datensatz enthält Angaben vom Magnetkompass, den nur wenige GPS-Geräte besitzen (vista, summit, GPS76s). Es sind Daten zur Richtung (170.4°) und Deklination (auch als 'deviation' bezeichnet; Abweichung von magnetisch Nord zu wahrem Nord, siehe auch hier).

$HCHDG,170.4,,,0.4,E*03

Der GPRTE-Datensatz schliesslich enthält Angaben zur programmierten Route. Zum Zeitpunkt des angebenen Datenblocks war keine Route definiert, ansonsten würde der Satz wesentlich mehr Informationen enthalten.

$GPRTE,1,1,c,*37

Andere GPS-Geräte enthalten teilweise andere herstellerspezifische Datensätze, die für die Position wichtigsten sind jedoch immer enthalten.

==Oft verwendeter Chipsatz SIRF==
Ein der am häufigsten eingesetzten Chipsätze für GPS-Empfänger stammt von der Firma SiRF Technology, Inc., ein Hersteller von GPS Chip-Sätzen.
Diese Firma verfolgt mit Nachdruck ihr Ziel, die Vorteile GPS-basierter Standortinformations-Technologie auf eine breite Palette von Massen- Consumerprodukten und -applikationen anzuwenden. SiRF GPS-Lösungen zeichnen sich durch eine Reihe herausragender Merkmale in technisch kritischen Bereichen aus. SiRF hat über 40 Patente für diese entscheidend wichtigen und innovativen Bereiche angemeldet.
SiRF hat die gesamte Komplexität, die GPS mit sich bringt in seine SiRFstar Architektur integriert. Dies erleichtert das Design von Produkten auf Basis der SiRF GPS Chip-Sätze erheblich. Die verschiedenen Architekturen sind für unterschiedliche Gruppen GPS-basierender Geräte ausgelegt.
Die SiRF GPS Technologien sind als Chip-Sätze sowie als IP Core verfügbar. Sie unterstützen vollständige Software Entwicklungsumgebungen. Beiden Architekturen liegen die gleichen Eigenschaften zugrunde die SiRF vorallem für den Einsatz in Consumer-Produkten prädestinieren.

--[[Benutzer:Bernd|Bernd]] 15:39, 13. Dez 2005 (CET)

==Quellen==
* http://www.kowoma.de/gps/zusatzerklaerungen/NMEA.htm
* http://netscience.univie.ac.at/nets/gps/content/huebscher/satellites/node15.html
* http://www.sirf.com

==Siehe auch==
* [[GALILEO]]

==Weblinks==
* http://www.nmea.org/
* http://kanadier.gps-info.de/d-gpsundkanu2.htm
* http://kanadier.gps-info.de/d-gpsundkanu.htm
* http://www.itwissen.info/details/definition/rubriken//GPS-Positionsbestimmung/index.html
* http://www.nmea.de/nmea0183datensaetze.html

[[Kategorie:Grundlagen]]
[[Kategorie:Abkürzung]]

C-Tutorial

2009-12-13T13:50:17Z

RobotProgger:

{{Ausbauwunsch|Mehr Grundlagen und vor allem Programmbeispiele etc.}}

Die Programmiersprache C wurde 1971 als Grundlage für das Betriebssystem UNIX in den USA entwickelt (UNIX ist zu über 90% in C geschrieben). 1978 wurde von Brian Kernighan und Dennis Ritchie eine eindeutige Sprachdefinition entwickelt. Mittlerweile ist C von ANSI und ISO standardisiert.

Heute sind C und ihr Nachfolger C++ die dominierenden Programmiersprachen. Sehr viele Anwendungen sind in C geschrieben, was inzwischen auch auf eingebettete Systeme zutrifft, die lange in Assembler programmiert werden mussten, da keine ausreichend leistungsfähigen [[Compiler]] zur Verfügung standen.

Leider ist C nicht einfach zu lernen – es wurde weder von noch für Hobby-Programmierer entwickelt – und eignet sich daher nur bedingt für den Einsteiger. Mit etwas Übung und einem optimierenden Compiler kann man damit jedoch sehr effiziente Programme schreiben.

Vom Design her ist C eine Hardware-unabhängig Sprache. Das bedeutet, daß C-Programme mit vertretbarem Aufwand auf ein anderes System portiert werden können. Dazu benötigt man lediglich einen anderen Compiler, und Inline-Assembler-Anweisungen (Assembleranweisungen innerhalb eines C-Programmes) müssen der neuen Hardware (Prozessor, [[Mikrocontroller]]) angepasst werden.

==Geschichte==
;1971: C wird entwickelt
;1978: Kernighan und Ritchie definieren die Sprache.
;1983: ANSI und ISO standardisieren C.
;1992: Bjarne Stroustrup enwickelt die Nachfolgesprache C++.

=Aufbau eines C-Programmes=

Ein einfaches C-Programm könnte folgendermassen aussehen. Das Programm tut eigentlich nichts, aber das Beispiel zeigt den prinzipiellen Aufbau.
#include <stdio.h>

int Zahl1;
char Zeichen1;

int main (void)
{
int zahl2;

{{comment|Anweisungen}}
return 0;
}

'''Beschreibung:'''

;<nowiki>#include <...></nowiki>: Die Include-Direktive sagt dem Compiler, welche Header-Dateien er einbinden soll. In den Header-Dateien und den dazugehörigen Bibliotheken stehen Funktionen und Datentypen, die nicht im Compiler selbst implementiert sind, etwa komplexe Ausgabefunktionen wie "<tt>printf</tt>", die weiter unten erklärt wird. Durch den Include kann man solche Funktionen nutzen. Elementare Dinge hingegen, wie die mathematischen Operatoren <tt>+</tt>,<tt>-</tt>,<tt>*</tt>, etc. sind im Compiler selbst eingebaut.
;int Zahl1;: Diese Zeile definiert eine Variable vom Typ int. Diese Variable ist im ganzen Programm gültig, sie ist ''global''. Jede Deklaration/Anweisung in C wird mit einem Strichpunkt (Semikolon <tt>;</tt>) abgeschlossen und dadurch von der nächsten Deklaration/Anweisung getrennt.
;char Zeichen1;: Hier geschieht das selbe, nur wird diesmal eine Variable des [[#Datentypen|Types char]] definiert.
;int main (void): definiert ein Unterprogramm mit dem Namen <tt>main</tt>, das keine Parameter hat (<tt>void</tt>) und eine ganze Zahl ([[#Datentypen|<tt>int</tt>]]) zurückliefert. "<tt>main</tt>" ist das Hauptprogramm in C, wo mit der Ausführung nach dem Programmstart begonnen wird.
;{: Die linke geschwungenen Klammer beginnt den Rumpf (auch "''body''" genannt) der main-Funktion. Danach folgen Variablendefinitionen, Kommentare und Anweisungen von <tt>main</tt>.
;int zahl2;: Innerhalb von "main" wird die lokale Variable <tt>zahl2</tt> definiert.
;/* Anweisungen */: Das ist ein Kommentar in C. Hier kann man Anmerkungen zum Code hinschreiben oder Codestücke "auskommentieren", um sie zu deaktivieren. Der Kommentar beginnt mit <tt>/*</tt> und wird beendet mit einem <tt>*/</tt>. Er kann mehrere Zeilen überspannen. Je nach C-Compiler werden auch einzeilige Kommentare mit <tt>//</tt> akzeptiert, die nur bis zum nächsten Zeilenende reichen. Sie gehören jedoch nicht zum standard ANSI-C. Die Leerzeile nach dem Kommentar wird nicht weiter berücksichtig, sie kann zur Untergliederung des Codes zur besseren Lesbarkeit eingefügt werden.
;return 0;: Gibt den Wert 0 zurück und beendet das Programm. Vor dem <tt>return</tt> können natürlich noch C-Anweisungen stehen, die aber erst weiter unten erklärt werden.
;}: Die schliessende geschwungenen Klammer beendet den Rumpf des Hauptprogramms.

=Das Hauptprogramm main=
Die erste Funktion, die nach dem Programmstart ausgeführt wird, ist im Allgemeinen die Funktion mit dem Namen "<tt>main</tt>". Diese ist das Hauptprogramm.

Der main-Funktion können beim PC Parameter übergeben werden. Dies sind die sogenannten Kommandozeilenparameter und evtl. Umgebungsvariablen, die beim Aufruf eines Programmes hinter dem Dateinamen stehen. Zudem wird auch ein int-Wert als Ergebnis zurückgeliefert, der den Aufrufer – üblicher weise eine Shell – den Erfolg bzw. Fehlerstatus des Programmes mitteilt.

Beim [[Microcontroller]] ist <tt>main</tt> das Startprogramm, das nach dem RESET und der Initialisierung aufgerufen wird. Hier gibt es also keine Funktionsparameter. Ein Rückgabewert ist auch nicht sinnvoll, so daß <tt>main</tt> oft als <tt>void</tt>-Funktion (ohne Rückgabewert) definiert wird. Um Compilerfehler/Warnungen zu vermeiden, muss der Compiler dann aber mit speziellen Einstellungen gestartet werden, denn C-Standard ist, daß main einen Wert zurückliefert!
{{comment|void-Definition von main ist nur beim Controller ueblich}}
{{comment|spezielle Compilereinstellungen sind noetig, damit bei dieser Definition von main}}
{{comment|kein Fehler/Warnung erzeugt wird.}}
void main ()
{
...
}

=Blöcke=
Im vorigen Abschnitt haben Sie bereits die geschwungenen Klammern { und } kennen gelernt. C-Programme sind in so genannte Blöcke unterteilt. Da gibt es zum einen das Hauptprogramm und die jeweiligen Unterprogramme, aber auch Schleifen und bedingte Anweisungen. Jedes dieser Konstrukte stellt ein eigenständiges Stück Code dar, das als solches gekennzeichnet werden muss.

Die Kennzeichnung für einen Blockanfang ist die öffnende geschweifte Klammer, während ein Blockende mit der schließenden Klammer notiert wird. Ein Block kann mehrere Teilblöcke enthalten, die wiederum Teilblöcke enthalten dürfen etc. Öffnende und schließende Block-Klammern tauchen immer paarweise auf.

Um Programme übersichtlich zu gestalten, wird jeder Block oder Teilblock eingerückt (siehe unten). Dann ist auch bei längerem Code sofort ersichtlich, wo ein Block beginnt und wo er endet. Geschweifte Klammern werden dann nur selten vergessen, und falls doch kann der Fehler schnell erkannt werden.

Variablen, die in einem Block deklariert werden, sind nur innerhalb dieses Blocks – und damit auch in allen seinen Teilblöcken – gültig.

int main (void)
{ {{comment|der Block "main" beginnt}}
int zahl;

{ {{comment|ein Block beginnt}}
{{comment|hier koennen Deklarationen und Anweisungen stehen}}
} {{comment|der Block endet}}

return 0;
} {{comment|"main" endet}}

=Datentypen=
==Elementare Datentypen==
Der Datentyp einer Variable gibt an, welche Werte eine Variable enthalten kann, welcher Art diese Daten sind und wie sie verarbeitet werden, etwa in arithmetischen Operationen wie einer Addition. So ist es zum Beispiel möglich, in eine Variable vom Typ <tt>int</tt> ganze Zahlen zwischen ca. -32000 und +32000 einzutragen. In einer char-Variable können ASCII-Zeichen gespeichert werden (alles, was Sie mit der Tastatur erzeugen können) oder ganze Zahlen von -128 bis 127.

;Achtung: Da C plattformabhängig ist, hängt die Größe eines Datentypes zum Teil von der genutzten Hardware (z.B. 8, 16 oder 32 Bit-Controller) und dem Compiler und dessen Einstellungen ab!

===int, char, short, long (ganze Zahlen)===
In Variablen dieser Typen können Sie ganze Zahlen abspeichern, also z.B. 1, <tt>-</tt>2, 100, 12345. Jeden dieser Typen gibt es in zwei Ausprägungen: als "<tt>signed</tt>", also als vorzeichenbehafteten Typ, und als "<tt>unsigned</tt>", also ohne Vorzeichen, d.h. das Vorzeichen wird als 0 oder +1 genommen.

Vorzeichenbehaftete Ganzzahl-Typen werden intern im <tt>n-1</tt>-Komplement dargestellt, das Vorzeichen selbst findet sich also im höchstwertigen Bit. Werden zur Speicherung ''b'' Bits verwendet, dann reicht der Wertebereich von <tt>-2''b''-1</tt> bis zu <tt>2''b''-1-1</tt>.

Bei Ganzzahl-Typen ohne Vorzeichen reicht der Wertebereich von <tt>0</tt> bis zu <tt>2''b''-1</tt>, wenn der Typ ''b'' Bits breit ist.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
! Größe (Bit) || Typ || Vorzeichen || colspan="2"| Grenzen des Wertebereichs
|-
| 8 || <tt>char</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -128 0
| align="right" | 127 255
|-
| 16 || <tt>short</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -32.768 0
| align="right" | 32.767 65.535
|-
| 32 || <tt>long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -2.147.483.648 0
| align="right" | 2.147.483.647 4.294.967.295
|-
| 64 || <tt>long long</tt>
| <tt>signed</tt> <tt>unsigned</tt>
| align="right" | -9.223.372.036.854.775.808 0
| align="right" | 9.223.372.036.854.775.807 18.446.744.073.709.551.615
|-
|8, 16, 32, 64 
| <tt>int</tt>
| <tt>signed</tt> <tt>unsigned</tt>
|plattform-/compilerabhängig
|plattform-/compilerabhängig
|}
</center>

==== Boolean (Logische Variablen)====
In der Sprache C gibt es keinen Datentyp für boolsche Werte "wahr" bzw. "TRUE" oder "falsch" bzw. "FALSE". Statt dessen wird gerne der Datentyp <tt>int</tt> dafür verwendet.
Hat die jeweilige Variable den Wert 0, so ist sie FALSE, sonst (ungleich 0) ist sie TRUE.
;Hinweis: Bitte beachten, daß eine Variable, die TRUE ist, nicht unbedingt den Wert 1 haben muß. Sie muß lediglich ungleich 0 sein!

====char (Zeichen)====
In einer <tt>char</tt>-Variable können Sie 8-Bit-Werte speichern. Dieser Datentyp wird oft für ASCII-Zeichen genutzt, denn für den Computer ist es egal, ob sich eine Zahl oder ein Zeichen in der Variablen befindet. Er speichert alles in Form von Binärzahlen.

Dabei darf man eines nicht vergessen: Es macht einen großen Unterschied, ob man in einer <tt>char</tt>-Variablen das Zeichen <tt>'1'</tt> (ASCII-Zeichen Nr. 49) abspeichert, oder die Zahl <tt>1</tt> (das entspricht ASCII-Zeichen Nr. 1, also irgendeinem Sonderzeichen). Man kann zwar mit beiden rechnen, aber <tt>'1' * 2</tt> ergibt nicht <tt>'2'</tt>, sondern <tt>'b'</tt> (ASCII-Zeichen Nr. 98)!

===float, double (Gleitkommazahlen)===
In einer Gleitkomma-Variable können Kommazahlen gespeichert werden, z.B. 3.141592654.
<tt>float</tt> reicht für die meisten Kommazahlen. Werden jedoch noch höhere Genauigkeiten benötigt, kommt der Datentyp <tt>double</tt> zum Einsatz.
;Vorsicht: bei PIC (microchip) ist die innere Darstellung dieser Zahlen anders als bei den meisten anderen Compilern, beim binären Senden z.B. zum PC muß dann konvertiert werden! Bei [[avr-gcc]] finden die Rechnungen intern mit <tt>float</tt> statt, auch wenn ein Typ als <tt>double</tt> deklariert ist.

===void===
Dies ist ein spezieller Typ, der soviel bedeutet wie "nicht vorhanden". Eine Funktion, die keinen Rückgabewert zurückliefert, definiert als Rückgabetyp <tt>void</tt>, und kennzeichnet damit, daß sie eben nichts zurückliefert. Objekte vom Typ <tt>void</tt> können nicht angelegt werden.

==Zeiger==
Jede Variable steht an einer definierten Stelle im Speicher, an ihrer sogenannten ''Adresse''.

Ein Zeiger ist eine Variable, in der eine Adresse gespeichert werden kann. Diese stellt eine bestimmte Position im Arbeitsspeicher dar. Die Adresse eines Objektes erhält man, indem man ihm ein <tt>&</tt> voranstellt. Die Umkehrung davon – also der Zugriff auf die Speicherstelle, die im Zeiger enthalten ist – erledigt ein vorgestellter <tt>*</tt>. Der Operator  <tt>*</tt> gibt also den ''Inhalt'' der Adresse.

<pre>
#include <stdio.h>

int main (void)
{
int * zeiger;
int zahl;

zeiger = &zahl;
*zeiger = 12;

printf ("%d = %d", zahl, *zeiger);

return 0;
}
</pre>

Die Definition von <tt>zeiger</tt> als Zeiger ist so zu lesen: Der Inhalt von <tt>zeiger</tt> ist ein <tt>int</tt>. Damit wird <tt>zeiger</tt> zu einem "Zeiger auf <tt>int</tt>". Dabei gehört der <tt>*</tt> sinngemäß zum Bezeichner <tt>zeiger</tt>, nicht zum Typ. Folgende Definition definiert also nicht zwei Pointer, sondern einen Pointer (auf <tt>int</tt>) sowie einen <tt>int</tt>:
int * zeiger, zahl;

Um den Zeiger mit der Adresse von <tt>zahl</tt> zu laden, schreibt man den Adress-Operator <tt>&</tt> von <tt>zahl</tt>:
zeiger = &zahl;
Jetzt möchten Sie der Speicherstelle, deren Adresse der Zeiger enthält, einen Wert zuweisen. Dazu verwendet man den "Inhalts-Operator" <tt>*</tt> (<tt>z.B. *zeiger = 12</tt>).
Genauso können Sie mit dem Inhaltsoperator Werte abfragen und an <tt>printf</tt> (und jedes andere Unterprogramm) übergeben.

==Enum==

Über <tt>enum</tt> können Aufzählungen definiert werden. Die Werte sind <tt>int</tt>-Werte und beginnen mit 0. Der folgende enum hat einen um 1 grösseren Wert. Mit einer Zuweisung können auch andere Werte zugeordnet werden. Klarer wird's im Beispiel:
<tt>
enum Farben
{
ROT,
GRUEN,
BLAU,
BRAUN = 5,
SCHWARZ
};
</tt>
Dies definiert die Konstanten <tt>ROT=0</tt>, <tt>GRUEN=1</tt>, <tt>BLAU=2</tt>, <tt>BRAUN=5</tt> und <tt>SCHWARZ=6</tt> und den Typ <tt>enum Farben</tt>:
<pre>
void foo (enum Farben farbe)
{
switch (farbe)
{
case ROT:
...
</pre>

Damit kann man anstatt "magischer" Zahlen sprechende Namen im Code verwenden, etwa in Berechnungen und Zuweisungen, Vergleichen oder als Konstante hinter einem <tt>case</tt>.

==Zusammengesetzte Datentypen==
===Arrays===
Oft muß man sehr viele Werte gleichzeitig abspeichern und betrachten, die alle der selben Aufgabe dienen. Man schreibt z.B. ein Programm, das 10 Zahlen einlesen und anschließend wieder ausgeben soll. Man könnte das natürlich mit 10 einzelnen Variablen bewerkstelligen, aber es ist sinnvoller, dabei Arrays – teilweise auch als ''Felder'' bezeichnet – zu verwenden.

In einem Array werden mehrere Variablen gleichen Typs zusammengefasst und hintereinander im Speicher abgelegt. So kann man viele tausend Variablen anlegen mit nur einer Zeile Code. Doch es gibt noch größere Vorteile: Sie können das Array mit einer Schleife ganz einfach nach Werten durchsuchen. Stellen Sie sich vor, Sie müssten mit 100 verschiedenen Variablen <tt>Zahl_00</tt> bis <tt>Zahl_99</tt> arbeiten!

'''Syntax:'''
{{Type}} {{Bezeichner}}[{{Konstante}}];

'''Beispiel:'''
unsigned int werte[100];

Der Name muß natürlich ein gültiger Bezeichner sein, als Datentyp kann jeder Typ genommen werden – sowohl elementare Datentypen als auch Zeiger, Strukturen, Unions oder selbst definierte Datentypen. In der eckigen Klammer wird die Anzahl der Elemente bekanntgegeben. Ein mit [3] definiertes Array hat Platz für drei Variablen. Da der Index immer bei 0 beginnt, greift man also mit <tt>[0]</tt>, <tt>[1]</tt> und <tt>[2]</tt> auf den jeweilige Inhalt zu. Um auf eine der im Array enthaltenen Variablen zugreifen zu können, müssen Sie den Variablennamen und in eckigen Klammern den Index (die "Nummer") der Variablen angeben. Diese Variable verhält sich dann wie eine ganz normale Variable des jeweiligen Datentypes.
#include <stdio.h>

#define NZAHLEN 10

int main(void)
{
int i;
int zahlen[NZAHLEN]; {{comment|zahlen[0] ... zahlen[9]}}

for (i=0; i < NZAHLEN; i++)
{
printf ("Bitte Zahl %d eingeben: ", i);
scanf ("%d", & zahlen[i]);
printf ("\n");
}

printf ("Super!\n");

for (i=0; i < NZAHLEN; i++)
printf ("Zahl %d ist: %d\n", i, zahlen[i]);

return 0;
}

Zuerst wird ein 10 int-Variablen großes Array angelegt.
In dieses wird nun der Reihe nach 10 Zahlen eingelesen.
Anschließend werden alle 10 Zahlen ausgegeben.

Dabei wird die Größe der Arrays und das Schleifenende über das Define "<tt>NZAHLEN</tt>" angegeben. Dadurch muss nur ''eine Stelle'' im Code geändert werden, wenn die Größe des Arrays einmal einen anderer Wert als 10 haben soll – dies vermeidet Fehler die dadurch entstehen, wenn man beim Anpassen der Array-Größe eine Codestelle vergisst, zudem wird der Code lesbarer als wenn irgendwo die Zahl "10" auftaucht.

{{FarbigerRahmen|
'''Merke:'''
:Wird ein ungültiger Index angeben (einer, der in der Deklaration nicht enthalten ist) können undefinierte Dinge passieren, wenn dadurch andere Variableninhalte oder Programmcode überschrieben wird, der hinter oder vor dem Array im Speicher liegt. Schlimmstenfalls kann sogar der Computer/Controller abstürzen. Also darauf achten, daß keine ungültigen Werte als Index auftreten!
}}

===Strings (Zeichenketten)===
Ein String ist nichts anderes als ein Array, das aus einzelnen Zeichen (<tt>char</tt>) gebildet wird. Die Ausgabe auf dem Bildschirm funktioniert am einfachsten mittels Strings.

Die Definition eines Strings erfolgt also genauso wie bei Arrays:
char string[21];

Nun haben Sie eine String, in dem Sie 21 Zeichen speichern können. Ganz richtig ist das jedoch nicht. C arbeitet mit "null-terminierten Strings". Das beudeutet, dass die Länge des Strings nicht abgespeichert wird, sondern das Zeichen mit dem ASCII-Wert 0 das Stringende kennzeichnet. Daher auch die Bezeichnung "null terminiert".

Das letzte Zeichen eines Strings muß daher immer das ASCII-Zeichen Nr. 0 sein. Ist es das nicht, hat der String kein definiertes Ende, und wenn Sie versuchen, ihn durch eine Standard-Funktion auszugeben zu lassen, könnte es eine Weile dauern, bis sich im Speicher zufällig irgendwo eine 0 befindet. Es stehen ihnen daher bei dem Beispiel nur 20 Zeichen zur Verfügung.

===Mehrdimensionale Arrays===
Manchmal benötigt man mehr als nur ein eindimensionales Array, wie Sie es bisher kennengelernt haben. Auch dies ist kein Problem. In der Deklaration geben Sie einfach mehrere eckige Klammern hintereinander an. Aber Vorsicht: der Speicherplatz ist begrenzt, ein "<tt>char feld[1024][1024]</tt>" hat die Speicherplatzgrenzen vermutlich bereits weit überschritten, und der Compiler wird einen (bei gewissen Einstellung auch keinen) Fehler liefern.
Beim Zugriff auf mehrdimensionale Felder müssen auch mehrere Indizes angeben werden:
<pre>
#include <stdio.h>

int main(void)
{
int x,y;
int feld[3][5];

for (x=0; x<3; x++)
{
for (y=0; y<5; y++)
{
printf ("Feldwert x: %d, y: %d ", x, y);
scanf ("%d", & feld[x][y]);
printf ("\n");
}
}

for(x=0; x<3; x++)
for (y=0; y<5; y++)
printf ("Wert: feld[%d][%d] = %d\n", x, y, feld[x][y]);

return 0;
}
</pre>

'''Erklärung:'''

Zuerst wird ein 3 mal 5 <tt>int</tt>-Array angelegt.
Dann werden die Werte eingegeben: zuerst <tt>feld[0][0]</tt>, dann <tt>feld[0][1]</tt>, usw. bis <tt>feld[2][4]</tt>.
Zum Schluß werden alle Werte noch einmal ausgegeben.

===Strukturen===
In C können Sie sogenannte "Strukturen" definieren. Dabei handelt es sich um eine Zusammenfassung mehrerer Datentypen zu einem größeren. Im Unterschied zu Feldern können in Strukturen unterschiedliche Datentypen zusammengestellt und gespeichert werden:

'''Syntax:'''
struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
};

'''Beispiel:'''
{{comment|Definition der Struktur 'Person'}}
struct Person
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
};

"<tt>struct Person {</tt>" leitet die Definition der Struktur mit dem Namen "<tt>Person</tt>" ein.
Dann werden in dieser Struktur fünf Komponenten definiert: drei Strings und zwei <tt>int</tt>.
mit <tt>}</tt> wird die Definition abgeschlossen. Sie haben damit einen Datentyp erstellt. Um eine Variable des Typs <tt>struct Person</tt> anzulegen, geben Sie einfach an
struct Person {{Bezeichner}};

Zum Zugriff auf eine Komponente der Struktur gibt man den Namen der Struktur-Variablen an (im folgenden Beispiel also <tt>hubert</tt> bzw. <tt>klaus</tt>), einen Punkt und danach den Bezeichner der Komponente:
{{comment|Definition zweier Struktur-Variablen}}
struct Person hubert, klaus;

{{comment|Zugriff auf Struktur-Komponenten}}
hubert.alter = 32;
klaus.alter = hubert.alter + 1;

'''Hinweis:'''
Der eventuell etwas lästige Gebrauch von <tt>struct</tt> kann schon bei der Definition der Struktur vermieden werden.
Der Definition ist ein <tt>typedef</tt> voranzustellen. Der Definition folgt dann ein gültiger (und auch eindeutiger) C-Name.

'''Syntax:'''
typedef struct {{Bezeichner}}
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur '_Mensch' bzw. 'Mensch'}}
typedef struct _Mensch
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

Jetzt sind folgende Deklarationen identisch:
struct _Mensch {{Bezeichner}};
Mensch {{Bezeichner}};

Ist der Struktuname nicht notwendig (im Beispiel oben <tt>_Mensch</tt>), kann auch kürzer geschrieben werden:

'''Syntax:'''
typedef struct
{
{{Deklaration}}
{{Deklaration}}
...
} {{Bezeichner}} ;

'''Beispiel:'''
{{comment|Definition der Struktur 'Mensch'}}
typedef struct
{
int id;
char vname[20], nname[20];
char telnr[15];
int alter;
} Mensch;

In diesem Fall ist lediglich die Deklaration <tt>Mensch {{Bezeichner}};</tt> gültig.

Der Hinweis gilt sinngemäß auch für die Definition <tt>union</tt> im nachfolgenden Abschnitt.

===Unions===
Eine Union wird ganz analog zu einer Struktur deklariert und verwendet. Sie unterscheidet sich von einer Struktur jedoch dadurch, daß ihre Elemente nicht nacheinander im Speicher abgelegt werden, sondern sich überlagern. Auf die in einer Union enthaltenen Daten gibt es also verschiedene Sichten: je nachdem, welche Sicht bzw. Interpretation der Daten man gerne hätte, wählt man den gewünschten Zugriff.
<pre>
union Daten
{
int id;

struct Person u_person;

struct u_double
{
int id;
double wert;
};

struct u_pointer
{
int id;
union Daten * p1;
union Daten * p2;
};
};

union Daten data;
</pre>
Dies definiert eine Union mit den vier Zugriffsmöglichkeiten <tt>id</tt>, <tt>u_person</tt>, <tt>u_double</tt> und <tt>u_pointer</tt>. Die Größe der Union richtet sich dabei nach der größten Komponente. In diesem Beispiel sind alle Komponenten so angelegt worden, daß sie an erster Stelle ein <tt>int id</tt> enthalten. In <tt>data.id</tt> könnte man sich also merken, wie die Daten in der Union zu interpretieren sind. Würde <tt>struct Person</tt> nicht dieses <tt>id</tt> enthalten, so würde sich <tt>data.id</tt> mit <tt>data.u_person.vname</tt> überlagern. Ein Ändern der ersten Buchstaben von <tt>vname</tt> hätte also ein Ändern von <tt>id</tt> zur Folge, und man könnte es nicht mehr als Merker verwenden. Mit diesem Feld überlagert das <tt>id</tt> von <tt>data</tt> die <tt>id</tt>-Felder der anderen Sichten, z.B. ist <tt>data.id</tt> der selbe Zugriff wie auf <tt>data.u_person.id</tt>.

Ein anderes Beispiel ist eine Union, die es ermöglicht, auf die einzelnen Bytes eines <tt>long</tt> zuzugreifen:
<pre>
typedef union
{
unsigned long as_long;
unsigned short as_short[2];
unsigned char as_byte[4];
} data32_t;
</pre>
Dies überlagert einen <tt>unsigned long</tt> – also eine 32-Bit-Zahl – mit vier Bytes bzw. zwei Shorts.
data32_t wert;

wert.as_long = 0x12345678;
wert.as_byte[0] = 0xab;
{{comment|nun ist wert.as_long gleich 0xab345678 oder 0x123456ab (je nach Plattform)}}

==Eigene Datentypen==

=Variablen=
Eine Variable ist ein Synonym (=anderer Name) für eine Speicherstelle in einem Computer. Einfacher gesagt, eine Variable bietet Raum, um Daten wie Zahlen oder Zeichen zu speichern und wieder zu lesen.

==Variablennamen==
Ein Variablenname kann zusammengesetzt werden aus den Buchstaben <tt>'''A'''</tt> bis <tt>'''Z'''</tt> und <tt>'''a'''</tt> bis <tt>'''z'''</tt>, den Ziffern <tt>'''0'''</tt> bis <tt>'''9'''</tt>, sowie dem Sonderzeichen "Unterstrich" (underscore) <tt>'''_'''</tt>. Dabei darf an erster Stelle keine Ziffer stehen. Die Bezeichner <tt>hallo</tt>, <tt>HALLO</tt>, <tt>Hallo</tt>, <tt>HALL0</tt>, <tt>_123</tt> und <tt>_HALLO</tt> sind also alle gültige und unterschiedliche Variablennamen.

==Anlegen von Variablen==
Um eine Variable verwenden zu können, muss sie zuerst vereinbart ("erzeugt") werden. Dies wird auch als "''Definition der Variablen''" bezeichnet und geht so: Schreiben Sie zuerst den Datentyp, dann den Namen der Variablen. Zum Schluß kommt noch der Strichpunkt, wie nach jeder C-Anweisung oder Deklaration. Und nicht vergessen: C unterscheidet zwischen Groß- und Kleinschreibung!
int Zahl1, Zahl2;
char Zeichen;

int main (void)
{
float gleitZahl;
{{comment|Anweisungen}}

return 0;
}

'''Erklärung:'''
In einer Zeile können auch mehrere Variablen gleichen Types vereinbart werden, wenn man ein Komma dazwischen setzt. Variablen können in jedem Block vereinbart werden. Siehe [[#Gültigkeitsbereich|Gültigkeitsbereich]].

==Zuweisungen==
Man kann einer vereinbarten Variable Werte [[#Zuweisungen|zuweisen]]. Dazu schreibt man zuerst den Variablennamen, ein Gleichheitszeichen "<tt>=</tt>" und anschliessend den zuzuweisenden [[#Ausdrücke|Ausdruck]].
<pre>
int main (void)
{
int zahl1, zahl2 = 12;
char zeichen1 = 'A';

zahl1 = 52;
zeichen1 = zeichen1 + 1;

return 0;
}
</pre>
Zuerst werden drei Variablen angelegt (<tt>zahl1</tt>, <tt>zahl2</tt>, <tt>zeichen1</tt>).
;<tt>zahl2</tt>: wird gleich bei der Vereinbarung der Wert 12 zugewiesen.
;<tt>zahl1 = 52</tt>: Hier wird der Variablen <tt>zahl1</tt> der Wert 52 zugewiesen.
;<tt>zeichen1</tt>: wird um 1 erhöht. Da in der Variablen <tt>'A'</tt> gespeichert ist, gibt sich ihr neuer Wert aus <tt>'A' + 1</tt>. Weil <tt>'A'</tt> dem Wert 65 entspricht, ist <tt>'A' + 1</tt> gleich 66, was dem Wert für <tt>'B'</tt> entspricht.

==Zuweisungen bei float==
Das funktioniert genau wie bei normalen Zuweisungen. Nachkommastellen werden durch einen Punkt abgegrenzt:
floatVariable = 3.14;
Zusätzlich kann eine Zehnerpotenz angegeben werden:
floatVariable2 = -1.234E-6;
Dadurch wird der erste Wert mit 10<tt>-</tt>6 multipliziert, der Wert der Variablen ist also
:<math>-1{,}234\cdot10^{-6} = -0.000001234</math>.

==Zuweisungen bei logischen Variablen==
Wie bereits erwähnt, besitzt C keinen logischen Datentyp. Es müssen also <tt>int</tt> oder <tt>char</tt> dafür genutzt werden. Die Zuweisung entpricht der Standard-Zuweisung. Wird der Wert 0 zugewiesen, dann ist die Variable "unwahr", ansonsten ist sie "wahr".
intVariable = !0; /* entspricht "wahr" */
intVariable = 0; /* entspricht "unwahr" */

==Konstanten==
Konstanten können als Variable angesehen werden, die nicht beschrieben, sondern nur gelesen werden können. Ein typisches Beispiel dafür ist die Zahl <math>\pi</math> (rund 3,141592654). Niemand würde in der realen Welt versuchen, ihr einen anderen Wert zuzuweisen. Würde man <math>\pi</math> jedoch wie eine normale Variable anlegen, wäre dies ohne weiteres möglich. Um dies zu verhindern, gibt es das Schlüsselwort <tt>const</tt> in C:
const {{Type}} {{Bezeichner}} = {{Konstante}}; {{comment|Zuweisung bei der Defininition der Variablen}}

Wichtig dabei ist, dass man Konstanten nur bei der Vereinbarung einen Wert zuweisen kann.
Da Konstanten gewöhnlich im gesamten Programm, zumindest einer Quelldatei genutzt werden, definiert man diese allerdings gewöhnlich außerhalb des main-Blockes entweder am Anfang eines Programmes, oder in einer sogenannten Header-Datei, die per <tt>#include</tt> eingebunden wird.
const float PI = 3.141592; {{comment|Zuweisung bei der Defininition der Variablen}}

Es sei jedoch erwähnt, daß auch einer Konstanten nachträglich ein anderer Wert zugewiesen werden kann. Im obigen Beispiel könnte mit
* ((float*) &PI) = 2;
der Wert von <tt>PI</tt> im Nachhinein verändert werden. Es wird die Adresse von <tt>PI</tt> genommen und diese Adresse durch den Cast in eine ganz normale <tt>float</tt>-Adresse umgewandelt, über welche der Wert geändert wird. Die sei der Vollständigkeit halber erwähnt.

Je nachdem, an welcher Stelle sich das <tt>const</tt> bei einer Pointer-Deklaration befindet, markiert es den Pointer als konstant oder das Objekt, auf das dieser Pointer zeigt. Eine häufige Parameterdeklaration in Ausgabe-Funktionen, die einen String erhalten, ist
void foo (const char * str, ...);
Dadurch ist <tt>str</tt> der Zeiger auf eine Zeichenkette, die innerhalb der Funktion nicht verändert wird bzw. verändert werden darf. Eine Zuweisung wie <tt>*str = 'a'</tt> ergibt also einen Fehler. <tt>str</tt> selbst kann aber sehr wohl verändert werden, etwa mit <tt>str++</tt>.

Soll ausgedrückt werden, dass <tt>str</tt> unveränderlich ist, dann so:
void foo (char * const str, ...);
Jetzt wäre eine Änderung des Strings in Ordnung, etwa durch <tt>str[10] = 'a'</tt>.

Um sich zu merken, worauf das <tt>const</tt> wirkt, trennt man die Deklaration in Gedanken beim <tt>*</tt> auf: Steht das <tt>const</tt> links vom <tt>*</tt>, dann gehört es zum <tt>char</tt>, steht es rechts davon, dann gehört es zum Pointer. Natürlich ist es auch denkbar, beides – also den Zeiger und sein Ziel – als konstant zu markieren.

==Gültigkeitsbereich==
In C können mehrere Variablen den gleichen Namen haben, solange eindeutig ist, welche in welchem Block gültig ist. Dabei gelten folgende Regeln:

;Lokale Variablen: sind Variablen, die innerhalb eines Blockes definiert werden. Jede Variable ist nur in dem Block gültig, in dem sie vereinbart wurde, sowie in allen darin enthaltenen Blöcken; es sei denn, in einem Unter-Block wird eine Variable gleichen Namens definiert. Dann bezieht sich in diesem Unter-Block der Bezeichner auf die im Unter-Block angelegte Variable.
;Globale Variablen: werden ausserhalb jedes Blockes definiert und gelten ab der Stelle, an der sie deklariert werden, siehe auch [[#Deklaration und Definition|Deklaration und Definition]]. Wird jedoch in einem Block eine Variable gleichen Namens angelegt, gilt ab hier bis zum Ende des Blocks nicht mehr die globale Variable, sondern die im Block deklarierte. Das Spiel kann man weiterspielen: wird in einem Unter-Block wieder eine namensgleiche Variable angelegt, gilt diese in dem Unterblock.

==Speicherklassen==
Jede Variable in C gehört zu einer bestimmten Speicherklasse
;<tt>auto</tt>: Lokale Variablen sind in aller Regal sogenannte ''automatische Variablen''. Das bedeutet, sie werden automatisch angelegt, wenn ein Block bzw. eine Funktion betreten wird und danach wieder entfernt. Das Schlüsselwort "<tt>auto</tt>" wird praktisch nie hingeschrieben, denn lokale Variablen ohne die ausdrückliche Angabe einer Speicherklasse, sind automatisch automatische Variablen.
;<tt>extern</tt>: Ein externes Symbol ist im ganzen Programm bekannt bzw. in dem Block, in der die Deklaration steht. In unterschiedlichen Blöcken stehende Deklarationen beziehen sich auf das gleiche Symbol! Obgleich das Datum global zugreifbar ist, ist der Gültigkeitsbereich auf den deklarierenden Block begrenzt bzw. auf das deklarierende Quell-Modul, sofern das Symbol ausserhalb jedes Blocks des Moduls deklariert wird. Siehe auch [[#Deklaration und Definition|Deklaration und Definition]].
;<tt>static</tt>: Die Variable ist im Block gültig bzw. im Quell-Modul (also in der C-Datei, in der die angelegt wurde), wenn sie nicht innerhalb eines Blockes angelegt wurde. Statische Variablen werden nicht in Registern oder im Frame der Funktion angelegt, sondern im selben Speicherbereich, in dem auch die globalen Variablen liegen; Konstanten evtl. auch im Flash. Eine lokale Variable, die als <tt>static</tt> angelegt wird, "überlebt" also das Verlassen des Blocks und hat beim neuerlichen Betreten des Blockes ihren bisherigen Wert. In unterschiedlichen Blöcken angelegte lokale statische Variablen beziehen sich auf unterschiedliche Speicherstellen, genau wie bei lokalen Variablen auch.
;<tt>register</tt>: Durch diese Speicherklasse wird eine Variable – falls möglich – als Registervariable angelegt, also in einem Maschinenregister des Computer/Controllers gehalten. Dadurch kann auf solche Variablen besonders schnell zugegriffen werden. Dieses Schlüsselwort ist bei modernen Compilern weitgehend überflüssig, da die entsprechenden Optimierungen selbständig vorgenommen werden, wenn ausreichend Register vorhanden sind. Auch globale Variablen können als Register angelegt werden, davon ist dem Anfänger aber dringend abzuraten, weil leicht schwerauffindbare Fehler und Abstürze auftreten, wenn man nicht genau weiss, welche Implikationen in einer solchen Definition stecken!
;<tt>volatile</tt>: (FIXME: volatile ist ein Qualifier und keine Speicherklasse) Dies ist das genaue Gegenteil von <tt>register</tt> und bewirkt, dass die Variable auf keinen Fall in einem Register zwischengespeichert werden darf, sondern immer aus dem RAM gelesen und ins RAM geschrieben werden soll. <tt>volatile</tt> müssen alle ''globalen'' Variablen markiert werden, die in [[ISR | Interrupt-Handlern]] verwendet werden.

=Ausdrücke=
Eine Variable oder eine Konstante in C stellen einfache Ausdrücke dar.
Diese elementaren Ausdrücke können durch Operatoren miteinander verknüpft werden und so zu neuen, komplexeren Ausdrücken zusammen gesetzt werden.

Einfache Beispiele für Ausdrücke sind also z.B.:
1
a
'a'
1 + a
a == 1

Auch Funktionen können einen Wert zurückliefern und in Ausdrücken weiter benutzt werden.
In den folgenden Abschnitten wird gezeigt, welche Operatoren in C vorhanden sind,
und wie man damit neue Ausdrücke aufbauen kann.

==Lvalues==

Ein Lvalue in C ist ein Ausdruck, dem ein anderer Ausdruck zugewiesen werden kann, dessen Wert also durch eine Zuweisung verändert werden kann.
das 'L' leitet sich ab von 'left' bwz. 'links' und das 'value' bedeutet Wert: Ein Lvalue ist ein Ausdruck, der auf der linken Seite einer Zuweisung stehen darf. Ein Lvalue ist also immer auch ein gültiger Ausdruck, aber die Umkehrung gilt in aller Regel nicht.

Ein einfaches Beispiel für einen Lvalue ist eine "normale" Variable, die nicht mit <tt>const</tt> als Konstante markiert ist:
a = 1;
Hingegen ist der Ausdruck <tt>a+1</tt> kein Lvalue, denn eine Zuweisung wie
a+1 = 2;
die mathematisch durchaus sinnvoll ist, erzeugt einen Compilerfehler, der etwa lauten könnte "illegal lvalue in assignment":
"ungültiger Wert in Zuweisung"

Andere Beipiele für Lvalues sind die Komponenten von (nicht-konstanten) [[#Strukturen|Strukturen]] und [[#Unions|Unions]], [[#Arrays|Array]]-Elemente und die Dereferenzierungen von Pointern: Die Konstante 4 wird durch den Cast in eine Adresse umgewandelt. Über die Dereferenzierung <tt>*</tt> wird an die Adresse 4 im Speicher eine 3 geschrieben. Ob das erlaubt bzw. sinnvoll ist, ist abhängig von der jeweiligen Architektur.
* ((unsigned int *) 4) = 3;
Hier ist der gesamte <tt>*</tt>-Ausdruck ein Lvalue

==Logische (boolsche) Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a && b</tt> || wahr, wenn <tt>a</tt> wahr und <tt>b</tt> wahr
|-
||<tt>a <nowiki>||</nowiki> b</tt> || wahr, wenn <tt>a</tt> wahr oder <tt>b</tt> wahr
|-
|<tt>a == b</tt> || gleich
|-
|<tt>a != b</tt> || ungleich
|-
|<tt>a <= b</tt> || kleiner oder gleich
|-
|<tt>a < b</tt> || kleiner als
|-
|<tt>a >= b</tt> || glösser oder gleich
|-
|<tt>a > b</tt> || grösser als
|-
|<tt>!a</tt> || wahr, wenn <tt>a</tt> nicht wahr und vice versa
|}
</center>

Eine interessante Eigenschaft der Operatoren <tt>&&</tt> und <tt>||</tt> ist, dass
sie die Auswertung abbrechen, sobald das Ergebnis feststeht. Die Ausdrücke werden
dabei immer von links nach rechts ausgewertet. Ein oft anzutreffendes Codestück sieht so aus, dabei sei <tt>p</tt> ein Zeiger auf einen <tt>int</tt>:

'''Beispiel:'''
if (p && *p == 5)
{
{{comment|mach was}}
}
Zuerst wird in der Bedinung geprüft, ob Zeiger <tt>p</tt> einen Wert ungleich Null hat, also ob er überhaupt einen gültigen Wert enthält. Es ist eine weit verbreitete Konvention in C, daß Zeiger, die keinen gültigen Wert haben, die Adresse 0 enthalten. '''Nur dann, wenn ein Zeiger nicht ein Null-Pointer ist, darf überhaupt ein Zugriff über ihn erfolgen!'''

==Vergleich von Variablen==
Skalare Variablen (also ganze Zahlen, Gleitkommazahlen, Zeiger) können miteinander verglichen werden. Dazu gibt es die folgenden Operatoren in C:
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!| Operator || Bedeutung
|-
| <tt>==</tt> || ist gleich
|-
| <tt>!=</tt> || ist nicht gleich
|-
| <tt><</tt> || ist kleiner
|-
| <tt><=</tt> || ist kleiner oder gleich
|-
| <tt>></tt> || ist größer
|-
| <tt>>=</tt> || ist größer oder gleich
|}
</center>
Das Ergebnis der Auswertung ist eine ganze Zahl. Ist die Bedingung erfüllt, dann ist der Wert ungleich 0. Ist die Bedingung nicht erfüllt, dann ist ihr Wert gleich 0.
Meistens wird man diese Operatoren in <tt>if</tt>-Konstrukten finden wie zum Beispiel
if (x >= 10)
x = 10;
oder in Abbruchbedingungen von Schleifen, wie sie weiter unten erklärt werden.

Es ist auch möglich, das Ergebnis der Auswertung in einer <tt>int</tt>-Variablen zu speichern:
int i;
int z1, z2;

z1 = 5;
z2 = 100;
i = z1 <= z2; {{comment|Ein Vergleich. i wird "wahr", da z1 kleinergleich z2 ist}}

Die Variable <tt>i</tt> ist ungleich 0 ("wahr"), wenn <tt>z1</tt> kleiner oder gleich <tt>z2</tt> ist. Ist <tt>z1</tt> jedoch größer als <tt>z2</tt>, dann ist <tt>i</tt> gleich 0 ("unwahr").

==Arithmetische Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a + b</tt> || Summe (Addition)
|-
|<tt>a - b</tt> || Differenz (Subtraktion)
|-
|<tt>a * b</tt> || Produkt (Multiplikation)
|-
|<tt>a / b</tt> || Quotient (Division, evtl. mit Rest)
|-
|<tt>a % b</tt> || Rest bei Division (Modulo)
|-
|<tt>-a</tt> || Vorzeichenumkehr (Zweierkomplement)
|}
</center>
==Bit-Operatoren==
<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a & b</tt> || bitweise und (and)
|-
|<tt>a <nowiki>|</nowiki> b</tt> || bitweise oder (or)
|-
|<tt>a ^ b</tt> || bitweise exclusiv-oder (xor, exor)
|-
|<tt>~a</tt> || jedes Bit in <tt>a</tt> invertieren (not, Einerkomplement)
|}
</center>
==Index-Operator bei Arrays==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a[b]</tt> || das (b+1)ste Element des Feldes a
|}
</center>

Folgendes gilt es bei der Verwendung des Indexoperators zu beachten:

# <tt>a</tt> muss ein [[C-Tutorial#Felder | Feld]] oder [[C-Tutorial#Zeiger | Zeiger]] sein
# <tt>b</tt> muss ein Integer sein oder ein Datentyp, der sich in einen int umwandeln läßt (z.B. char)
# Es wird nicht geprüft, ob der Index <tt>b</tt> im Feld <tt>a</tt> gültig ist!
# Der erste Index eines Feldes ist immer 0. Daher ''(b+1)stes Element'' in der Beschreibung

==Komponenten-Auswahl bei Structs und Unions==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>a.b</tt> || Element b der [[C-Tutorial#Strukturen | Struktur]] oder des Unions a
|}
</center>

==Adress-Operator und Dereferenzierung==

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Ausdruck ||Beschreibung
|-
|<tt>&a</tt> || Speicheradresse der Variablen <tt>a</tt>
|-
||<tt>*a</tt> || Wert, der an der Adresse <tt>a</tt> steht
|-
||<tt>a->b</tt> || Wert des Elements <tt>b</tt> der Struktur, deren Adresse in <tt>a</tt> steht
|}
</center>

Der Adressoperator & kann auf Variablen angewendet werden und
gibt die Startadresse der Variablen im Speicher zurück.

Handelt es sich bei einer Variable um einen [[C-Tutorial#Zeiger | Zeiger]], so enthält
sie eine Speicheradresse. Um an den '''Wert''' zu gelangen, der
an dieser Adresse steht, wird der Operator * vorangestellt.

'''Beispiel:'''

{{comment|x ist eine Integervariable und hat den Wert 5}}
int x = 5;

{{comment|z ist ein Zeiger auf eine Integer-Variable und enthaelt somit}}
{{comment|die Speicheradresse einer Integer-Variablen}}
int *z;

{{comment|Verwendung des Adress-Operators: weist an z die Adresse von x zu}}
z = &x;

{{comment|Verwendung der Dereferenzierung}}
{{comment|erhoehe den Wert, der bei Adresse z steht, um eins}}
*z = *z + 1;

{{comment|da z auf x zeigt, hat x jetzt den Wert 6}}

Da in C häufig Zeiger auf [[C-Tutorial#Strukturen | Strukturen]] verwendet werden, ist für den Zugriff auf Struktir- und Union-Elemente eine abkürzende Schreibweise möglich:

Statt
(*strukturZeiger).element
kann geschrieben werden
strukturZeiger->element
Beide Schreibweisen sind absolut gleichbedeutend, die Klammern bei der ersteren sind notwendig.

'''Achtung!'''
:Bei der Dereferenzierung durch <tt>*</tt> findet keine Prüfung statt, ob der Zeiger auch auf eine gültige Speicheradresse verweist. Folgendes Codestück führt zum Absturz oder zu einer Änderung '''irgendeiner''' Speicherstelle!

int *z; {{comment|z ist ein Zeiger auf einen int}}

{{comment|An dieser Stelle ist z immer noch keine Speicheradresse zugewiesen.}}
{{comment|z enthaelt irgendeine ungueltige Adresse!!}}

{{comment|"Erhoehe einen Integer _irgendwo_ im Speicher um 1" -> CRASH !!!}}
*z = *z + 1;

Viele C-Compiler erzeugen in der Standardeinstellung für das obige Codestück ''keine Warnung''!

==Cast-Operator==

Der Cast Operator dient dazu, den Datentyp eines Wertes zu ändern. Dafür wird einfach der neue Datentyp in Klammern vor den Wert geschrieben.

Um zum Beispiel aus einem Float ein Integer zu machen:
var = (int) 5.60;
Dabei wird der Wert aber auch gerundet, und es findet somit ein Informationsverlust statt. (Genau genommen wird nicht gerundet, sondern die Nachkommastellen werden nur abgeschnitten; wenn man runden möchte, empfiehlt es sich, zuerst 0.5 zu addieren und dann zu casten.)

Ein weiteres Beispiel ist das Umwandeln einer ganzen Zahl in eine Adresse:
int * addr;
addr = (int*) 0x1234;
Damit ist <tt>addr</tt> ein Zeiger auf einen <tt>int</tt> an Adresse 0x1234.

{{FarbigerRahmen |
'''Achtung!'''

Der Cast-Operator selbst führt ''keine Konvertierung'' von Darstellungen durch, etwa die Umwandlung der ganzen Zahl 123 ein den String <tt>"123"</tt>, der diese Zahl darstellt!
<pre>
#include <stdio.h>
int main(int argc, char ** argv)
{
char text[] = "5.6";
int zahl = (int) text;

printf("%d\n", zahl);

return 0;
}
</pre>
Ausgegeben wird weder 5 noch 6 sondern die Anfangsadresse des Strings <tt>"5.6"</tt>.
}}

==Komma-Operator==
Mit einem <tt>,</tt> können mehrere Ausdrücke nacheinander ausgewertet werden.
Die Auswertung erfolgt von links nach rechts.

Solche Konstrukte sieht man manchmal in Abfragen wie
FILE *file;
if (file = fopen ("foo.exe", "r"), file != NULL)
was erst an <tt>file</tt> einen Wert zuweist und den <tt>if</tt>-Block nur betritt,
wenn <tt>file</tt> nicht der Nullpointer ist.

Bequem kann das auch in einer [[#for-Schleife|for-Schleife]] sein, wenn man zwei (oder mehr) Laufvariablen hat oder so:
for (i=0, j=0; i < 10; i++, j += 2)
···

==Zuweisungen und Operatoren mit Nebeneffekt==
===Zuweisung===
=== ++ und -- ===

<tt>++</tt> und <tt>--</tt> stellen einfachere Schreibweisen dar zum Addieren bzw. Subtrahieren von 1.

'''<tt>++</tt> (Inkrementieren)'''
int foo = 1;
foo++;
{{comment|entspricht}}
foo = foo + 1;
{{comment|jetzt ist foo = 3}}

'''<tt>--</tt> (Dekrementieren)'''
int foo = 1;
foo--;
{{comment|entspricht}}
foo = foo - 1;
{{comment|jetzt ist foo = -1}}

Die beiden Operatoren können sowohl in der Präfix-Schreibweise (vor der Variablen) als auch als Postfix-Schreibweise (hinter der Variablen) notiert werden.
Der Unterschied liegt darin, dass beim Präfix der Wert zuerst neu berechnet wird und die Variable dann verwendet wird. Beim Postfix wird die Variable zuerst verwendet und erst nach Auswertung des Ausdrucks, in dem sie enthalten ist, neu berechnet.

'''Beispiel'''
int ausgabe1, ausgabe2, var1 = 10, var2 = 10;
ausgabe1 = 3 * ++var1; {{comment|ausgabe1 = 33; var1 = 11;}}
ausgabe2 = 3 * var2++; {{comment|ausgabe2 = 30; var2 = 11;}}

Für Zeiger arbeiten diese Operatoren etwas anders, siehe dazu [[#Zeiger-Arithmetik|Zeiger-Arithmetik]].

===Bedingter Ausdruck===
({{Bedingung}}) ? {{Ausdruck|1}} : {{Ausdruck|2}}
Wenn <tt>Bedingung</tt> erfüllt ist, dann wertet dieser Ausdruck aus zu <tt>Ausdruck1</tt>. Ist er nicht erfüllt, dann wertet er aus zu <tt>Ausdruck2</tt>.

'''Beispiel:'''
x = (x >= 3) ? 0 : x+1;
Startet man <tt>x</tt> mit dem Wert 0, dann nimmt es bei mehrfacher Anwendung dieser Zeile (z.B. in einer Schleife) nacheinander die folgende Werte an:
:<tt>1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, ...</tt>

==Reihenfolge der Auswertung==

Wie auch in der Mathematik gibt es auch in C genaue Regeln über die Abarbeitungsreihenfolge (precedence)
der Operatoren. Dass sich alle C-Compiler genau an diesen ANSI-Vorschlag halten, ist leider nicht sicher.
Sicher jedoch ist, dass nicht jeder Programmierer diese Regel jederzeit im Kopf hat.
Daher ist es sinnvoll, Ausdrücke durch runde Klammern eindeutig zu kennzeichnen.
Nebenbei stören sich Compiler nicht an überflüssigen Klammerpaaren.

<center>
{| {{Blauetabelle}}
|- {{Hintergrund1}}
!|Priorität ||Operator||Assoziativität
|-

|<tt>15</tt> ||<tt> ( ) [ ] -> . </tt> ||von links nach rechts
|-
|<tt>14</tt> ||<tt>! ~ ++ -- + - (TYP) * & sizeof </tt> ||von rechts nach links
|-
|<tt>13</tt> ||<tt> * / % (Rechenoperationen) </tt> ||von links nach rechts
|-
|<tt>12</tt> ||<tt> + - (binär) </tt> ||von links nach rechts
|-
|<tt>11</tt> ||<tt> << >> </tt> ||von links nach rechts
|-
|<tt>10</tt> ||<tt> < <= > >= </tt> ||von links nach rechts
|-
|<tt> 9</tt> ||<tt> == != </tt> ||von links nach rechts
|-
|<tt> 8</tt> ||<tt> & (bit-AND-Operator)</tt> ||von links nach rechts
|-
|<tt> 7</tt> ||<tt> ^ (bit-XOR-Operator)</tt> ||von links nach rechts
|-
|<tt> 6</tt> ||<tt> <nowiki>|</nowiki> (bit-OR-Operator)</tt> ||von links nach rechts
|-
|<tt> 5</tt> ||<tt> && </tt> ||von links nach rechts
|-
|<tt> 4</tt> ||<tt> <nowiki>||</nowiki> </tt> ||von links nach rechts
|-
|<tt> 3</tt> ||<tt>? : </tt> ||von rechts nach links
|-
|<tt> 2</tt> ||<tt> = += -= /= *= %= >>= <<= &= <nowiki>|</nowiki>= ^= </tt> ||von rechts nach links
|-
|<tt> 1</tt> ||<tt> , (Sequenz-Operator) </tt> ||von links nach rechts
|-

|}
</center>

Die Reihenfolge der Auswertung von Funktionsargumenten ist in der ANSI-Spezifikation nicht angegeben und daher compilerabhängig. Von Konstrukten wie
{
int i=0;
func (i++, i++);
}
ist also dringend abzuraten!

=Kontrollanweisungen=

Eine Kontrollanweisung ist eine Anweisung, die Einfluss auf den Programmfluss hat. Normalerweise werden Anweisungen so ausgeführt, wie sie in der Quelldatei stehen: Von links nach rechts (falls mehrere Anweisungen in einer Zeile stehen sollten, wovon i.A. abzuraten ist) und von oben nach unten. Mit einer Kontrollanweisung kann dieser lineare Programmfluss durchbrochen werden: Die Codeausführung kann kann abhängig von einer Bedingung gemacht werden (<tt>if</tt>), kann wiederholt werden (Schleife) oder an einer anderen Stelle der Funktion fortgesetzt werden (<tt>goto</tt>).

==if-Anweisung==
Mit Hilfe des if-Befehls kann man Codeteile abhängig davon einer Bedingung ausführen lassen:

'''Syntax:'''
if ({{Bedingung}})
{{Anweisung}}
oder mit else-Teil
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

'''Beispiel:'''
if (x > 100)
{
{{comment|falls x > 100 ist: Fehlerausgabe}}
printf ("x = %d ist zu gross fuer die Berechnung!\n", x);
}
else
{
{{comment|falls x <= 100 ist: Berechne Summe der Zahlen 1...x}}
{{comment|Die lokale Variable x2 lebt nur innerhalb dieses alse-Blocks}}
int x2 = x;

for (x = 0; x2 > 0; x2--)
x += x2;
}

Wenn die Bedingung wahr ist (<tt>x > 100</tt>), dann wird eine Meldung ausgegeben; danach ist die if-Anweisung beendet. Der else-Block wird also nicht ausgeführt.

Ist die Bedingung nicht erfüllt (<tt>x ≤ 100</tt>), dann wird gleich zum else-Teil gesprungen, und nach dessen Ausführung der if-Befehl beendet.

{{FarbigerRahmen|
Ein häufiger Fehler ist es, statt <tt>if (a == 23)</tt> etwas wie <tt>if (a = 23)</tt> zu schreiben.
Dann wird allerdings nicht geprüft, ob die Variable <tt>a</tt> gleich 23 ist, sondern der Variablen <tt>a</tt> wird der Wert 23 zugewiesen. Der Ausdruck <tt>a = 23</tt> hat den Wert 23 und ist damit immer "wahr"! Daher ist diese if-Bedingung immer erfüllt!

Die Syntax hierbei ist allerdings korrekt, der Compiler wird also keinen Fehler ausspucken sondern bestenfalls eine Warnung. Damit ist dieser Fehler sehr schwer zu finden. Abhilfe schafft die Schreibweise <tt>if (23 == a)</tt>. Wenn man dort anstatt des Vergleichsoperators '<tt>==</tt>' den Zuweisungsoperator '<tt>=</tt>' verwendet, spuckt der Compiler sehr wohl einen Fehler aus! Ist die Zuweisung jedoch erwünscht und eine Compiler-Warnung lästig, dann wählt man eine Schreibweise wie <tt>if ((a = b))</tt> oder <tt>if (a = b, a)</tt>.

Ein weiterer häufiger Fehler ist zu schreiben <tt>if (Bedingung);</tt> Richtig muss es heissen "<tt>if(Bedingung)</tt>" Das Semikolon im ersten Fall ist eine leere Anweisung, die im if-Falle ausgeführt wird – sie bleibt also ohne Resultet. Auch hier liegt kein Syntaxfehler vor und der Compiler schweigt; ein auf das Semikolon folgende Anweisung die eigentlich zum <tt>if</tt> gehören soll wird immer ausgeführt, die sie nicht mehr zum <tt>if</tt> dazu gehört.
}}
Bei verschachtelten <tt>if</tt>-<tt>else</tt>-Konstrukten gehört ein <tt>else</tt> zu letzten "freien" <tt>if</tt>. Soll in einer <tt>if</tt>-<tt>if</tt>-<tt>else</tt>-Folge das <tt>else</tt> zum ersten <tt>if</tt> gehören, dann ist das so zu hinzuschreiben:
if ({{Bedingung}})
{
if ({{Bedingung}})
{{Anweisung}}
}
else
{{Anweisung}}
Ohne die geschweiften Klammern um das zweite <tt>if</tt> gehörte das <tt>else</tt> dort hinzu.

==switch-Anweisung==
'''Syntax:'''

switch ({{Ausdruck|}})
{
case konstante1:
{{Anweisung}}
{{Anweisung}}
...
break;

case konstante2:
{{Anweisung}}
{{Anweisung}}
...
break;

{{comment|weitere case-Marken}}

default:
{{Anweisung}}
{{Anweisung}}
...
} {{comment|Ende von switch}}

Der Ausdruck muss ein skalarer Typ sein, er wird in die nächste ganze Zahl gewandelt und mit den Werten hinter den <tt>case</tt>-Marken verglichen. Bei einer Übereinstimmung werden alle Befehle ab dem zutreffenden <tt>case</tt> ausgeführt. Stimmt der Ausdruck mit keinem der Werte überein, so wird der <tt>default</tt>-Abschnitt ausgeführt falls vorhanden.

Auch die Anweisungen der nachfolgenden <tt>case</tt>- und des <tt>default</tt>-Abschnitts werden ausgeführt, wenn die Anweisungen des <tt>case</tt>-Abschnitts nicht mit dem Befehl <tt>break;</tt> beendet werden!

Es dürfen beliebig viele <tt>case</tt>-Abschnitte angegeben werden, pro Vergleichswert jedoch nur einer.
Der <tt>default</tt>-Abschnitt ist optional. Die Reihenfolge, in der <tt>case</tt> und <tt>default</tt> angegeben werden, ist unerheblich.

==Schleifen==
Um Anweisungen mehrmals hintereinander auszuführen, benötigt man Schleifen. Diese führen Anweisungen aus, bis oder solange Bedingungen erfüllt sind. 
Wichtig ist also, ob die Bedingung '''vor''' oder '''nach''' den Schleifen-Anweisungen geprüft wird.

===while-Schleife===
'''Syntax:'''
while ({{Bedingung}})
{{Anweisung}}

Die while-Schleife wird solange durchlaufen, wie die Bedingung erfüllt ist. Die Schleife wird also unter Umständen garnicht durchlaufen. Die Anweisung kann natürlich auch ein Block sein, der aus mehreren Deklarationen und Anweisungen besteht.

int zahl1 = 0;
int zahl2 = 1;

while (zahl1 < 3)
{
zahl1 = zahl1 + 1;
zahl2 = zahl2 * 2;
}

In diesem Beispiel wird die Schleife drei mal durchlaufen. Zu Beginn des vierten Durchlaufs ist die Bedingung nicht mehr erfüllt (<tt>zahl1</tt> ist dann nicht mehr kleiner, sondern gleich 3!), also wird mit dem Befehl nach der Schleife fortgesetzt.

===do-while-Schleife===
'''Syntax:'''
do
{{Anweisung}}
while ({{Bedingung}});

Die do-while-Schleife wird auf jeden Fall einmal durchlaufen und dann solange wiederholt, wie die Bedingung erfüllt ist.
int i = 2;

do
{
i = i*i; {{comment|i quadrieren}}
printf ("i = %d\n", i);
}
while (i < 20);

Die Schleife wird durchlaufen und wiederholt, solange <tt>i</tt> kleiner als 20 ist. Es werden also nacheinander die Werte 2, 4 und 16 ausgegeben. Nach der Schleife hat <tt>i</tt> den Wert 256.

===for-Schleife===
'''Syntax:'''
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}

Bei den Ausdrücken wird es sich um einen Ausdrücke mit Nebeneffekt handeln wie etwa <tt>i=0</tt> oder <tt>i=i+2</tt>. Es werden folgende Aktionen ausgeführt:
# <tt>Ausdruck1</tt> wird ausgewertet
# <tt>Bedingung</tt> wird ausgewertet
# falls die Bedingung wahr ist, dann führe <tt>Anweisung</tt> aus.
# falls die Bedingung unwahr ist, dann sprinte zu 7 (Ende).
# <tt>Ausdruck2</tt> wird ausgewertet
# gehe zu 2
# nächste Anweisung nach der for-Schleife

'''Beispiel:'''
int lauf, summe;

for (lauf=1, summe=0; lauf <= 10; lauf += 2)
{
summe += lauf;
}

In diesem Beispiel ist <tt>Ausdruck1</tt> ein [[#Komma-Operator|Komma-Ausdruck]], der zwei Anweisungen kombiniert und daher sogar zwei Nebeneffente hat: er setzt <tt>lauf</tt> auf 1 und <tt>summe</tt> auf 0.

Das Äquivalent als while-Schleife:

int lauf = 1; {{comment|Anfangswerte}}
int summe = 0;

while (lauf <= 10) {{comment|Bedingung}}
{
summe += lauf;
lauf += 2; {{comment|Inkrement}}
}

In diesem Beispiel wird <tt>summe</tt> in jedem Schleifendurchlauf um die Laufvariable <tt>lauf</tt> erhöht. Da <tt>lauf</tt> nacheinander die ungeraden Werte von 1 bis 10 annimmt, ist in <tt>summe</tt> nach der Schleife die Summe der ungeraden Zahlen von 1 bis kleinergleich 10 gespeichert, also der Wert 25. <tt>lauf</tt> hat nach der Schleife den Wert 11.

'''Erklärung:'''
<tt>lauf = 1</tt> bedeutet, dass der Variablen <tt>lauf</tt> vor dem ersten Schleifendurchlauf der Wert 1 zugewiesen wird.
<tt>lauf <= 10</tt> ist die Schleifenbedingung; ist sie nicht erfüllt, wird die Schleife beendet.
<tt>lauf += 2</tt> bedeutet, dass <tt>lauf</tt> nach jedem Durchlauf um 2 erhöht wird.

===continue-Anweisung===
Innerhalb einer Schleife darf die <tt>continue</tt>-Instruktion stehen. Sie bewirkt, daß die nachfolgenden Anweisungen übersprungen werden und mit dem nächsten Schleifendurchlauf fortgesetzt wird – vorausgesetzt die Schleifenbedingung ist noch erfüllt. Ein <tt>continue</tt> darf natürlich auch innerhalb eines <tt>if</tt> oder <tt>switch</tt> etc. stehen, wenn dieses innerhalb einer Schleife steht.

==break-Anweisung==
Innerhalb einer Schleife oder eines <tt>switch</tt> darf die <tt>break</tt>-Instruktion stehen. Sie bewirkt, daß die Schleifen-/Switch-Anweisung sofort verlassen wird und das Programm dahinter weiter macht. Bei mehrfach geschachtelten Schleifen wird nur die innere verlassen. Ein <tt>break</tt> darf natürlich auch innerhalb eines <tt>if</tt> stehen, wenn dieses innerhalb einer Schleife/Switch-Anweisung steht.

==goto-Anweisung==

Innerhalb ein und derselben Funktion kann mit <tt>goto</tt> an eine andere Stelle gesprungen werden. Dazu gibt man hinter dem <tt>goto</tt> einen Bezeichner an, der dadurch als Label fungiert:

'''Syntax:'''
goto {{Bezeichner}};
Die Bezeichner selbst steht irgendwo in der Funktion und wird dadurch zur Sprungmarke (Label), daß er von einem Doppelpunkt (und mindestens einer C-Anweisung, die auch leer sein darf) gefolgt wird.

Das Beispiel durchsucht das 2-dimensionale <tt>int</tt>-Array <tt>feld</tt> mit den <tt>SIZE_X × SIZE_Y</tt> Werten nach dem Wert <tt>0</tt>. Wird er gefunden, dann wird die 2-fach geschachtelte Suchschleife verlassen.

'''Beispiel:'''
int x, y;

for (x=0; x < SIZE_X; x++)
for (y=0; y < SIZE_Y; y++)
if (feld[x][y] == 0)
goto done;
{{Label|done:}};

Der folgende Code hat die gleiche Funktion, arbeitet jedoch ohne <tt>goto</tt>:
int x, y;
int found = 0; {{comment|FALSE}}

for (x=0; x < SIZE_X && !found; x++)
for (y=0; y < SIZE_Y && !found; y++)
found = (0 == feld[x][y]);
Der Nachteil der <tt>goto</tt>-losen Variante ist, daß man eine Variable, die merkt, ob das Suchziel gefunden wurde, mitschleppen und in ''jedem'' Schleifendurchlauf abtesten muss. Dies bedeutet einen höheren Programmier- und Laufzeitaufwand und ist nicht so klar formuliert wie das <tt>goto</tt>-Beispiel.

Gleichwohl sei angemerkt, daß die Verwendung von <tt>goto</tt> einem gewissen Dogmatismus unterliegt, der sich wie folgt subsummieren liesse:
:''goto ist böse und sollte keinesfalls verwendet werden! Wer es dennoch tut, offenbart dadurch seinen schlechten Geschmach sowie mangelhafte C-Kenntnis.'' <div align="right">http://www.roboternetz.de/phpBB2/images/smiles/icon_wink.gif</div>

=Funktionen=
Stell Dir vor, Du hast eine Code-Folge, die mehrmals im Programm vorkommt, z.B. eine mathematische Formel. Anstatt dieses Codestück mehrmals zu schreiben – was Dich Zeit beim Erstellen des Programms und Speicherplatz im ausführbaren Programm kostet – kannst Du den Code-Abschnitt in eine Funktion schreiben und diese von jeder Stelle des Programms aus verwenden. Die Hauptgründe, um Funktionen zu verwenden, sind:
;Wiederverwendung von Code: Mehrfach verwendete Codestücke müssen nicht mehrfach implementiert werden. Oft unterscheiden sich die Codesequenzen nur in Kleinigkeiten, die man der Funktion über Parameter mitteilen kann.
;Übersichtlichkeit: Ein gut gegliedertes C-Programm implementiert klar umrissene Aufgaben in einer Funktion, auch wenn diese Funktion nur einmal im Code aufgerufen wird! Dadurch bleibt der Code um die Aufrufstelle besser verständlich, und man kann auf verschiedenen "Ebenen" denken. Eine Funktion wie "Datei öffnen" kann recht komplex sein. Auf höherer Ebene interessieren die Innereien nicht mehr, man möchte sich um andere Dinge kümmern und will den Code an der Stelle garnicht sehen...
;Rekursive Funktionen: Eine Funktion kann sich auch selbst aufrufen. In dem Falle nennt man die Funktion ''rekursiv''. Zwar lässt sich das, was eine rekursive Funktion tut, auch mit anderen Mitteln formulieren, die keine rekursiven Funktionen brauchen, aber oft ist der rekursive Weg knackiger und klarer formulierbar als eine nicht-rekursiven Ansatz, auch wenn es etwas mehr Resourcen verbraucht.
;Modulare Programmierung: Funktionen können anhand ihres Aufgabenbereichs auf verschiedene C-Quellen – sogenannte ''Module'' – verteilt werden. Funktionen, die etwas mit dem USB-Bus anstellen, werden in einem anderen Modul sein als mathematische Funktionen. Dies erhöht die Übersichtlichkeit und vereinfacht die Entwicklung im Team.
;Bibliotheken: Standard-Funktionen wie das hier oft auftauchende <tt>printf</tt> sind in Bibliotheken gespeichert. Wenn das eigene Programm übersetzt wird, dann müssen nicht mehr alle Standard-Funktionen übersetzt werden, sondern werden nur noch aus der Bibliothek gelesen und ihr Code zum Programm dazugelinkt. Die Bibliotheks-Funktionen wurden schon zu einem früheren Zeitpunkt compiliert und liegen in dieser compilerten Form in der Bibliothek. Das spart mächtig Entwicklungszeit. Man kann auch selbst solche Bibliotheken erstellen und in diversen Projekten wiederverwenden.
;Generische Programmierung: In C ist es möglich, einer Funktion eine andere Funktion zu übergeben. (Damit ist nicht gemeint, ihr deren ''Rückgabewert'' zu übergeben (was auch ginge), sondern ''die Funktion selbst'' wird als Parameter übergeben und kann aufgerufen werden.) Ein typisches Beispiel dafür sind Sortieralgorithmen. Einem Sortieralgorithmus kann es egal sein, ''was'' er sortiert. Er muss lediglich wissen, ''wie'' er das Zeug zu sortieren hat: aufsteigend, absteigend, als Zahl, in lexikographischer Ordnung, nach der Quersumme, Körper nach Oberfläche, Durchmesser, Gewicht oder Volumen... Diese Vergleichsfunktion, die für zwei Objekte entscheidet, welches davon "kleiner" ist, kann man dem Sortierer übergeben. Will er zwei Werte vergleichen, dann muss er nur die Vergleichsfunktion aufrufen, ohne zu wissen, was diese tut. Damit kann der Sortieralgorithmus unanhängig von den Objekten gehalten werden, mit denen er hantieren soll.

==Definition==

In der ''Definition'' der Funktion wird gesagt, welche Werte sie liefern kann, wie sie heisst (Bezeichner) und wieviele und welche Parameter sie hat. Danach folgt ihre Implementierung:

'''Syntax:'''
{{Type}} {{Bezeichner}} ({{Parameterliste}})
{
{{Deklaration}}
{{Deklaration}}
...

{{Anweisung}}
{{Anweisung}}
...
}
Für Funktionen, die keinen Wert zurückliefern, gibt es den speziellen Typ <tt>void</tt>, der besagt, daß die Funktion nichts zurückgibt. Die einfachste denkbare Funktion ist eine solch void-Funktion. Sie bekommt keine Parameter, gibt nicht zurück und ihr Body ist leer:
void dummy()
{
}

==return-Anweisung==
An jeder Stelle des Programmflusses einer Funktion kann diese mit <tt>return</tt> beendet werden.

'''bei void-Funktionen:'''
return;
'''Funktionen mit Rückgabe-Wert:'''
return {{Ausdruck|}};
Die zweite Variante gibt an, welcher Wert zurückgegeben wird.
int main (int argc, char * argv[])
{
if (argc < 2)
return -1;

return 0;
}
Falls die letzte Anweisung einer void-Funktion ein <tt>return</tt> ist, kann es auch weggelassen werden wie oben bei der Funktion <tt>dummy</tt>.

==Aufruf==
Um die Funktion aufzurufen gibt man ihren Namen an, gefolgt von den durch Komma getrennten Argumenten in runden Klammern wie im Beispiel unten das
quadrat (5)
Da <tt>quadrat</tt> einen Wert liefert, kann man damit weiter rechnen wie mit einem normalen Ausdruck:
if (quadrat (a) + quadrat (b) == quadrat (c))
c = quadrat (quadrat (a)); {{comment|c = a hoch 4}}

;Ein Hinweis am Rande: Der Name einer Funktion ohne die beiden runden Klammern ist der Pointer/Zeiger auf ihren Anfang. Damit kann ein Funktionsname überall dort verwendet werden, wo Pointer/Zeiger zulässig sind. Insbesondere kann er als Argument einer weiteren Funktion dienen. Siehe auch [[#Zeiger auf Funktionen|Zeiger auf Funktionen]].

==Rekursive Funktionen==
Eine Funktion die sich selbst – möglicheweise auch über andere Zwischenfunktionen – wieder selbst aufruft, wird als ''rekursive Funktion'' bezeichnet. In der Definition ist nichts besonderes zu beachten. Ist die Verschachtelungstiefe im laufenden Programm zu tief, dann gibt das natürlich Probleme, aber das gilt bei tief verschachtelten 'normalen' Funktionen ebenso...

Das Beispiel berechnet den Größten Gemeinsamen Teiler zweier Zahlen <tt>a</tt> und <tt>b</tt>:
int ggT (int a, int b)
{
if (0 == a)
return b;

return ggT (b % a, a);
}

==Beispiel==

Ein komplettes kleines Programm:
<pre>
#include <stdio.h>

int quadrat (int param1)
{
int zahl;
zahl = param1 * param1;
return zahl;
}

int main ()
{
int zahl, ergebnis;

printf ("Bitte Zahl eingeben: ");
scanf ("%d", &zahl);

ergebnis = quadrat (zahl);

printf ("%d hoch 2 = %d\n", zahl, ergebnis);
printf ("%d hoch 2 = %d\n", 5, quadrat (5));

return 0;
}
</pre>

Ein Unterprogramm kann an jeder beliebigen Stelle innerhalb eines Programmes stehen, aber nur ausserhalb von Blöcken. Geschachtelte Unterprogramme sind in Standard-C nicht möglich.

{{FarbigerRahmen |
'''Merke:''' Auch wenn eine Funktion keine Parameter hat, müssen beim Aufruf die Klammern angeben werden:
dummy();
}}

==Prototypen==
Wie oben erwähnt, kann ein Unterprogramm an jeder beliebigen Stelle im Programm stehen. Damit ist jedoch eine Bedingung verknüpft: Das Unterprogramm muß in der Datei oberhalb des ersten Aufrufes definiert worden sein. Wenn Sie ein Unterprogramm in Zeile 10 zum ersten mal aufrufen, müssen Sie die Deklaration davor erledigt haben. Verstanden?
Um dies zu erreichen, gibt es zwei Möglichkeiten:

Entweder Sie schreiben alle Unterprogramme vor <tt>main</tt> in die Datei. Dies muß jedoch wiederum so geschehen, dass Funktionen zum Zeitpunkt ihres Aufrufes bereits bekannt sind!
Wo dies nicht möglich ist (z.B. sich gegenseitig aufrufende Unterprogramme), oder wenn Sie das stört, müssen Sie Prototypen verwenden.
Wie definiert man nun Prototypen? Sie kopieren einfach die erste Zeile des Unterprogrammes (z.B. "<tt>void ausgeben (int zahl)</tt>"), fügen einen Strichpunkt <tt>;</tt>an und fügen es an einer geeigneten Stelle ein (so, dass alle Aufrufe später in der Datei kommen).
Solche Definitionen stehen gewöhnlich am Anfang der Quelldatei oder in einer Header-Datei, die eingebunden wird.

<pre>
#include <stdio.h>

void ausgeben (int zahl); /* Der Prototyp */

int main (void)
{
ausgeben (12);

return 0;
}

void ausgeben (int zahl) /* Die eigentliche Prozedur */
{
printf ("Ausgabe: %d\n", zahl);
}
</pre>

==Parameterübergabe==

Alle Werte, die an Prozeduren und Funktionen übergeben werden, werden grundsätzlich '''kopiert'''.
Das hat folgende Auswirkungen:

# Änderungen an einem Parameter in einer Funktion erscheinen ''nicht'' beim Aufrufer!
# Möchte man, dass eine Funktion einen Wert trotzdem dauerhaft ändern soll, so muss die Adresse des Wertes via [[#Zeiger|Zeiger]] übergeben werden.
# Werden [[#Strukturen|Strukturen]] übergeben, so wird von ihnen eine Kopie erstellt, was bei großen Strukturen viel Zeit und Arbeitsspeicher kostet. Deshalb wird häufig nur die Adresse von Strukturen übergeben, da die Adresse viel schneller und platzsparender als die Struktur selbst kopiert werden kann.

'''Beispiele:'''
void erhoehe (int x)
{
x = x + 1;
}

int main (void)
{
int a = 0;
erhoehe(a);
{{comment|a ist immer noch 0}}

return 0;
}

Beim Aufruf von <tt>erhoehe</tt> wird eine Kopie des Wertes von <tt>a</tt> (im Beispiel also 0) erstellt und der Prozedur als Parameter <tt>x</tt> übergeben. Weil dann die Prozedur <tt>erhoehe</tt> die Kopie verändert, hat dies keine Auswirkung auf das Original <tt>a</tt> im Hauptprogramm.

void erhoehe (int *x)
{
{{comment|erhoehe den Wert an der Adresse x um eins}}
*x = *x + 1;
}

int main(void)
{
int a = 0;
erhoehe (&a);
{{comment|a ist jetzt 1}}

return 0;
}

Jetzt wird im Hauptprogramm mittels [[#Adress-Operator und Dereferenzierung|Adress-Operator]] <tt>&</tt> die Speicheradresse von <tt>a</tt> bestimmt. Dann wird eine ''Kopie der Adresse'' an das Unterprogramm <tt>erhoehe</tt> übergeben. Jetzt kennt das Unterprogramm die
Adresse des Originals <tt>a</tt> und kann direkt mit dem Inhalts-Operator <tt>*</tt> auf den Wert an dieser Adresse zugreifen.

'''Besonderheit bei Feldern'''

Bei der Übergabe von [[#Felder|Feldern]] gibt es eine Besonderheit. Schreibt man nämlich den Namen eines Feldes, so ist das nichts anderes als die '''Speicheradresse des ersten Elements'''.
Bei der Übergabe eines Feldes wird also eine Kopie der Startadresse übergeben. Somit kann das Unterprogramm auf den Originaldaten arbeiten und diese verändern.

'''Beispiel:'''
void erhoehe (int x[])
{
x[0] = x[0] + 1;
x[1] = x[1] + 3;
x[2] = x[2] + 5;
}

int main(int argc, char **argv)
{
int a[] = {10, 20, 30};

erhoehe (a);
{{comment|a hat jetzt folgenden Inhalte: 11, 23, 35}}

return 0;
}

Dass die Übergabe einer Adresse erfolgt, sieht man an folgendem Beispiel, das von der Funktionsweise '''absolut identisch''' mit dem vorhergehenden ist:

{{comment|Bei Parametern gibt es keinen Unterschied zwischen Zeiger und Feld}}
void erhoehe (int *x)
{
x[0] = x[0] + 1;
x[1] = x[1] + 3;
x[2] = x[2] + 5;
}

int main(int argc, char **argv)
{
int a[] = {10, 20, 30};

erhoehe (a);

{{comment|a hat jetzt folgenden Inhalt: 11, 23, 35}}
}

{{FarbigerRahmen |
Die Länge des Feldes wird nicht automatisch übergeben. Dafür ist ggf. ein zusätzlicher Parameter notwendig.
}}

==Inlining==

In C gibt es die Möglichkeit, eine Funktion als ''inline''-Funktion zu definieren.
Für eine inline-Funktion wird üblicher Weise kein Code erzeugt, der beim Aufruf der Funktion angesprungen wird, sondern an der Stelle des Aufrufs wird eine Kopie der inline-Funktion eingefügt.

Vom Effekt her ist eine inline-Funktion also ähnlich wie ein Makro. Allerdings wird das Einfügen des Codes nicht vom Präprozessor übernommen, sondern vom eigentlichen C-Compiler. Damit der Compiler in der Lage ist, eine Funktion zu inlinen, muss ihm der Code zur Verfügung stehen, da er ansonsten natürlich keinen Code einfügen kann.

Das Schlüsselwort ist ''inline'':
{{ccomment|Deklariere ''increment'' als inline-Funktion}}
static inline int increment (int);

{{ccomment|Implementierung von ''increment''}}
int increment (int i)
{
return i+1;
}

{{ccomment|Aufruf von ''increment'' wie eine normale Funktion}}
int foo (int n)
{
if (n < MAX_INT)
n = increment (n);

return n;
}

Inline-Funktionen werden verwendet, wenn der Funktionscode recht klein ist und ein Funktionsaufruf schon so aufwändig ist wie das, was die Funktion zu erledigen hat. Im Beispiel wird der gleiche Code erzeugt, wie wenn <tt>n = n + 1</tt> im Aufrufer stünde, was deutlich schneller ist als ein Funktionsaufruf mit Register-Sicherung, Parameterübergabe, Wertrückgabe, etc.

==Variable Argumentanzahl==

In C ist es möglich, einer Funktion eine variable Anzahl an Argumenten zu übergeben. Solche Funktionen haben eine Anzahl benamter Argumente wie "normale" Funktionen auch, jedoch folgt nach dem letzten benamten Argument eine beliebige Anzahl weiterer Argumente.

Ein Beispiel für eine solche Funktion ist das Bekannte <tt>printf</tt>, für das zB folgende Aufrufe möglich sind:
printf ("Hallo");
printf ("%c", c);
printf ("%s %d", einString, 15);
printf ("%d %d %d", zahl1, zahl2, zahl3);

Einer solchen Funktion muss die Anzahl der Argumente mitgeleilt werden, die ihr übergeben werden. Sies könnte dadurch geschehen, daß man ihr die Argumentanzahl explizit übergibt. Bei <tt>printf</tt> wird die Anzahl der Übergabeparameter im Formatstring transportiert, ebenso wie die Typen der Übergebenen Variablen, denn die Funktion muss wissen, wie die übergebenen Werte zu interpretieren sind. Bei <tt>printf</tt> geschieht dies wiederum mittls des Format-Strings.

Der Prototyp einer varargs-Funktion sieht aus wie folgt, wobei die drei Pünktchen wörtlich zu nehmen sind und nicht etwa als abkürzende Schreibweise für die Parameterliste!
#include <stdio.h>
#include <stdarg.h>

extern void fprintf (FILE * file, const char * format, ...);
extern void printf (const char * format, ...);
extern void fprintf_va (FILE * file, const char * format, va_list args);

Die Funktion <tt>fprintf</tt> soll eine Ausgabe zum File (Stream) <tt>file</tt> erledigen und ansonsten genauso funktionieren wie das altbekannte <tt>printf</tt>. Es ist also anzustreben, in <tt>printf</tt> nur die File-Version aufzurufen um eine Doppel-Implementierung der Funktionalität zu vermeiden. Hierzu dient die Funktion <tt>fprintf_va</tt>, die von <tt>printf</tt> bzw. <tt>fprintf</tt> einen File-Pointer, den Format-String sowie die Argumente erhält:

void fprintf (FILE * file, const char * format, ...)
{
{{ccomment|Die Argumentliste 'args'}}
va_list args;
{{ccomment|Die variablen Argument beginnen nach 'format' }}
va_start (args, format);
{{ccomment|Die eigentliche Arbeit erledigt 'fprintf_va' }}
fprintf_va (file, format, args);
{{ccomment|fertig }}
va_end (args);
}

Fast genauso sieht unser <tt>printf</tt> aus:

void printf (const char * format, ...)
{
{{ccomment|Die Argumentliste 'args'}}
va_list args;
{{ccomment|Die variablen Argument beginnen nach 'format' }}
va_start (args, format);
{{ccomment|Die eigentliche Arbeit erledigt 'fprintf_va' }}
fprintf_va (stdout, format, args);
{{ccomment|fertig }}
va_end (args);
}

Was zu tun bleibt, ist die Implementioerung der eigentlichen Funktionalität in <tt>fprintf_va</tt>. Diese durchfostet den Format-String und bei jedem %-Ausdruck wird ein weiteres Argument eingelesen und an eine passende Ausgabefunktion delegiert. Hier wird der Einfachheit halber nur <tt>%c</tt> und <tt>%s</tt> implementiert:

static void fprintf_va (FILE * file, const char * fmt, va_list args)
{
char c;

{{ccomment|Nächstes Zeichen des Formatstrings lesen und String-Ende abtesten }}
while (c = *fmt++, c != '\0')
{
{{ccomment|Das Format-Zeichen }}
if ('%' == c)
{
{{ccomment|Weiterlesen: das Zeichen nach dem % }}
c = fmt++;

{{ccomment|%% --> ein % ausgeben }}
if ('%' == c) fputc ('%', file);
{{ccomment|%c --> Character ausgeben }}
else if ('c' == c) fputc (va_arg (args, int), file);
{{ccomment|%s --> String ausgeben }}
else if ('s' == c) fputs (va_arg (args, char*), file);
{{ccomment|Unbekannts %-Format }}
else fputs ("???", file);

{{ccomment|Falls ein % am String-Ende steht }}
if ('\0' == c) return;

continue;
}

{{ccomment|Für Win32: Zeilenumbruch ist carriage return + line feed }}
if ('\n' == c)
putc ('\r');

{{ccomment|Zeichen ausgenen }}
putc (c);
} {{ccomment|while }}
}

== Funktionen indirekt aufrufen ==
Siehe [[#Zeiger auf Funktionen|Zeiger auf Funktionen]]

=Zeiger II=

Zeiger haben wir bereits weiter oben kennen gelernt. Zeiger sind ein zentrales Konzept in C und sollen hier etwas eingehender behandelt werden.

==Zeiger-Arithmetik==
In C kann man den Wert eines Zeigers verändern. Betrachten wir dazu die Funktion <tt>suche_0</tt>, die einen Zeiger auf einen <tt>long</tt> erhält. Die Funktion soll ab der gegebenen Adresse nach dem ersten long-Wert suchen, der 0 ist, und dessen Adresse zurückgeben:
long * suche_0 (long * addr)
{
while (*addr != 0)
addr = addr + 1;

return addr;
}
In der Bedingung der while-Schleife wird der Inhalt an der Speicherstelle <tt>addr</tt> auf 0 getestet. Ist der Wert 0, dann wird die Schleife beendet und die Adresse zurückgeliefert. Ist der Wert ungleich 0, dann wird <tt>addr</tt> auf den nächste long gesetzt, <tt>addr</tt> also um 4 Bytes weitergezählt. <tt>addr</tt> ist ja ein Zeiger auf <tt>long</tt>, und ein <tt>long</tt> ist 4 Bytes lang.

Die Bedeutung von
address + n
ist also, die Adresse um das <tt>n</tt>-fache der Größe des Typs, auf den <tt>address</tt> zeigt, zu erhöhen. Dabei ist <tt>n</tt> eine ganze Zahl und darf auch negativ sein.

Hier noch ein Beispiel einer Funktion, die nach einer Person mit einer bestimmten ID sucht (für die Definition von <tt>struct Person</tt> siehe [[#Strukturen|Strukturen]]). Der Parameter <tt>person</tt> ist dabei ein Array von Strukturen. Eine Person mit der gesuchten ID muss existieren, ansonsten hat die Suchfunktion kein definiertes Verhalten.
{{comment|Sucht nach einer Person mit der ID person_id}}
struct Person *
suche_person_id (struct Person * person, int person_id)
{
while (person->id != person_id)
person++;

return person;
}

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Beachte, daß es nicht sinnvoll ist, zwei Zeiger zu addieren oder zu multiplizieren. Ausserdem ist das <tt>+</tt> der Zeiger-Arithmetik nicht kommutativ. Eine Zeiger auf <tt>long</tt>, der an Adresse 1 im Speicher zeigt, wird man schreiben als
(long *) 1
Addiert man darauf eine ganze Zahl, dann haben die entstehenden Ausdrücke unterschiedliche Werte:
(long *) 1 + 2 {{comment|zeigt zu Adresse 9}}
(long *) 2 + 1 {{comment|zeigt zu Adresse 6}}
(long *) (1 + 2) {{comment|zeigt zu Adresse 3}}
</div>

==void-Pointer==
Eine besondere Art von Zeiger ist der void-Pointer
void * addr;
Ein void-Pointer ist ein "Zeiger auf irgendwas", dementsprechend kann er nicht dereferenziert werden, Anwenden von <tt>*</tt> auf einen solchen Zeiger gibt also einen Fehler. Ausserdem ist es nicht möglich, mit einem void-Pointer Zeigerarithmetik zu machen, weil er nicht auf eine definierte Art von Objekt zeigt. Der Vorteil eines void-Pointers ist, daß er jede Art von Zeiger aufnehmen kann.

Dazu betrachten wir die Funktion <tt>send_buf</tt>, die eine Adresse erhält und ab dieser Adresse <tt>num</tt> Bytes versenden soll. Wir könnten die Funktion so schreiben:
void send_buf (unsigned char * buf, unsigned int num)
{
...
Das ist jedoch hässlich, wenn wir damit etwas anderes verschicken wollen als <tt> unsigned char</tt>, etwa eine Struktur wie <tt>hubert</tt> (vom Typ <tt>struct Person</tt>):
send_buf ((unsigned char*) & hubert, sizeof (struct Person));
Ohne den Cast der Adresse von <tt>hubert</tt> zu einem Zeiger auf <tt>unsigned char</tt> bekommt man eine Warnung oder gar einen Compilerfehler.
Dieses Zeiger gecaste ist mühsam und hässlich, es muss bei jedem Aufruf der Funktion explizit hingeschrieben werden.

Besser ist es, den ersten Parameter der Funktion als void-Pointer zu definieren und den Cast in der Funktion zu machen:
void send_buf (void * vbuf, unsigned int num)
{
unsigned char *buf = (unsigned char*) vbuf;
...
Durch den Cast in der Funktion kann auf den Inhalt des Zeigers zugegriffen werden. Man muss nur festlegen, ''wie'' man zugreifen will, nämlich als <tt>unsigned char</tt>.
Der Aufruf kann jetzt ohne Pointer-Cast erfolgen:
send_buf (& hubert, sizeof (struct Person));

==Null-Pointer==
==Zeiger als Parameter==
Wenn Sie ein Unterprogramm aufrufen, können Sie diesem Parameter übergeben, aber keine Werte zurückgekommen (außer den Funktionswert bei Funktionen). Dies hat einen guten Grund: beim Aufruf werden nicht die aufgerufenen Parameter benutzt, sondern es werden deren Werte in neue Variablen kopiert. Diese Variablen werden am Ende des Unterprogrammes "zerstört", ohne ihre Werte an die aufrufenden Parameter zu übergeben. Jede Veränderung eines Parameters hat daher keine Auswirkung auf den Parameter.

Doch was ist, wenn Sie Parameter in Unterprogrammen verändern möchten? Ganz einfach, Sie verwenden Zeiger. Der C-Compiler legt dann immer noch Kopien an. In dieser Kopie steht aber kein Wert, sondern die Adresse einer Varaiblen. Und auf diese können Sie dann zugreifen. Denken Sie nur an <tt>scanf</tt> – da übergeben Sie ja auch die Adresse einer Variablen.

<pre>
#include <stdio.h>

void erhoehe (int *zeiger)
{
*zeiger = 1 + *zeiger;
}

int main ()
{
int zahl;

printf ("Zahl eingeben: ");
scanf ("%d", &zahl);
erhoehe (&zahl);
printf ("\nDie erhoehte Zahl lautet: %d\n", zahl);

return 0;
}
</pre>

==Zeiger auf Funktionen==

Stell dir vor, du willst einen Sortieralgorithmus wie Bubble-Sort oder Quick-Sort oder wie sie alle heissen implementieren. Für den Sortieralgorithmus ist eigentlich egal, ''was'' er zu sortieren hat. Ihm ist es egal, ob er Zahlen aufwärts sortieren soll oder Strings in lexikographischer Reihenfolge, ob Objekte nach Größe oder Gewicht, Personen nach Alter oder Adressen nach Postleitzahl. Das einzige, was der Algorithmus wissen muss, ist ''wie'' er zwei Objekte zu vergleichen hat und wann eines davon "kleiner" (im Sinne der Ordnung, nach der sortiert werden soll) ist.

Eine einfache Sortierfunktion, die nur zwei Zahlen sortiert, könnte man also so schreiben:
{{comment|Sortiert ein Array von 2 int-Zeigern nach den Inhalten
* an den Zeiger-Adressen}}
void sort2_a (int * p[])
{
{{comment|Inhalte vergleichen...}}
if (*p[0] > *p[1])
{
{{comment|... und ggf. Dreieckstausch der 2 Zeiger}}
int * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Die Funktion bekommt ein Array der Länge 2. In diesem Array stehen Zeiger auf die zu sortierenden Zahlen. Ein Array mit Zeigern zu verwenden und nicht ein Array von <tt>int</tt> scheint recht umständlich, und das ist es hier auch. Aber stell dir vor, du willst Strukturen wie <tt>struct Person</tt> sortieren. Das Tauschen zweier Strukturen würde bedeuten, ihre kompletten Inhalte umzukopieren! Das wäre sehr aufwändig. Viel einfacher ist das Kopieren, wenn nur die Adressen zu kopieren sind.

Der Aufruf von <tt>sort2_a</tt> könnte dann so aussehen:
#include <stdio.h>

void sortiere (int a, int b)
{
{{comment|p[] enthält 2 int-Zeiger: die Adressen von a und b}}
int * p[2];
p[0] = &a;
p[1] = &b;

{{comment|Sortiere die Zeiger}}
sort2_a (p);

printf ("Sortiert: %d, %d\n", *p[0], *p[1]);
}

Für den nächsten Schritt überlegen wir uns, daß das Array in <tt>sort2_a</tt> ebensogut void-Pointer enthalten kann. Die einzige Stelle, an der wir auf die endgültigen int-Objekte zugreifen, ist der Vergleich. Diesen Vergleich lagern wir in die Funktion <tt>compare_int</tt> aus:
{{comment|Bekommt zwei void-Pointer und vergleicht die Inhalte.
* Liefert 0 bei Gleichheit,
* -1 wenn der erste Wert kleiner ist als der zweite und
* 1 wenn der erste Wert größer ist als der zweite}}
int compare_int (void * p0, void * p1)
{
{{comment|Um über die Zeiger zugreifen zu können müssen wir diese
* erst zu int-Zeigern casten}}
int a0 = * (int*) p0;
int a1 = * (int*) p1;

if (a0 > a1) return 1;
if (a0 < a1) return -1;

return 0;
}

void sort2_b (void * p[])
{
if (compare_int (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Ein Aufruf von <tt>sort2_b</tt> sieht dann genauso aus wie ein Aufruf von <tt>sort2_a</tt>.

Im nächsten Schritt definieren wir uns den neuen Datentyp <tt>comparator_t</tt>. Dieser ist ein Zeiger auf eine Funktion, die zwei void-Pointer erhält und einen <tt>int</tt> zurückliefert, also analog arbeitet zu <tt>compare_int</tt> von oben.

Unsere Sortierfunktion bekommt nun neben dem zu sortierenden Zeiger-Array auch eine Vergleichsfunktion <tt>compare</tt> mitgeliefert, die sie aufruft, wenn sie zwei Objekte vergleichen will
{{comment|comparator_t sind Zeiger auf Funktionen, die 2 void-Pointer
* erhalten und einen int zurückliefern}}
typedef int (*comparator_t) (void*, void*);

{{comment|Der Sortierer bekommt einen Funktionszeiger auf den Vergleicher.
* Der Aufruf vom compare geht so als wäre es eine "normale" Funktion
* (ist es im Endeffekt ja auch)}}
void sort2_c (comparator_t compare, void * p[])
{
if (compare (p[0], p[1]) > 0)
{
void * p0 = p[0];
p[0] = p[1];
p[1] = p0;
}
}
Bei einem Aufruf von <tt>sort2_c</tt> muss man dann einen Komparator mit angeben. In einem Beispiel analog zu <tt>sort2_a</tt> von oben ist das:
sort2_c (compare_int, p);
Um zwei Strings lexikographisch zu sortieren nehmen wie die Standard-Funktion <tt>strcmp</tt>:
#include <string.h>
#include <stdio.h>

void foo()
{
char * worte[] = { "Wort1", "Wort2" };

sort2_c ((comparator_t) strcmp, (void**) worte);
}
Die Casts sind hier erforderlich. Alternativ könnte man <tt>sort2_c</tt> mit reinen void-Pointern versorgen und diese dann dort umcasten.

===Syntax===

Die Syntax zur Definition/Deklaration von Funktionszeigern ist etwas verzwackt. Zur Verdeutlichung ein paar Beispiele. Dabei legt das linke <tt><Type></tt> jeweils den Return-Typ fest.
{{comment|definiert einen neuen Funktionszeiger-Typ}}
typedef {{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert eine Variable als Funktionszeiger}}
{{type}} (*{{bezeichner}}) ({{type}}, {{type}}, ...);

{{comment|deklariert ein Array von Funktionszeigern (mit Initializer)}}
{{type}} (*{{bezeichner}}[]) ({{type}}, {{type}}, ...) = { wert1, wert2, ... };

{{comment|Castet Bezeichner zu einem Funktionspointer}}
({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}

{{comment|Castet Bezeichner zu einem Funktionspointer und ruft die Funktion auf}}
(({{type}}(*)({{type}}, {{type}}, ...)) {{bezeichner}}) (arg1, arg2, ...);

=Standard-Funktionen=

==String-Funktionen==

===strcpy===
Bei vielen Compilern können sie einem String nicht direkt einen Wert (Text) zuweisen. Dazu müssen Sie dann die Prozedur strcpy() benutzen. Diese erwartet als ersten Parameter den Namen einer String-Variablen (ohne eckige Klammern) und als zweiten Parameter den eines (anderen) Strings. Letzterer kann auch ein in doppelten Hochkommas (") eingeschlossener Text sein. Die Funktion fügt am Ende automatisch ein 0-Zeichen ein. Um diese Funktion nutzen zu können, müssen Sie die Datei string.h includieren!

<pre>
#include <stdio.h>
#include <string.h>

int main (void)
{
char stri1[21], eingabe[21];

strcpy (stri1, "hallo");

printf ("Der 1. String: %s\n", stri1);
printf ("Bitte geben Sie maximal 20 Zeichen ein: ");
scanf ("%s", eingabe);
strcpy (stri1, eingabe);
printf ("\n%s = %s", stri1, eingabe);

return 0;
}
</pre>

'''Hinweis:'''
Da ein String, wie jedes Feld, eigentlich ein Zeiger ist, dürfen Sie kein <tt>&</tt> bei <tt>scanf</tt> angeben!

'''Erklärung:'''
Es werden zwei gleich große Strings definiert: <tt>stri1</tt> und <tt>eingabe</tt>, mit je 20 "nutzbaren" Zeichen.
In <tt>stri1</tt> wird die Zeichenkette <tt>"hallo"</tt> hineinkopiert. Das 0-Zeichen am Ende wird automatisch angefügt.
Der String wird ausgegeben. Als neues "Sonderzeichen" kommt <tt>%s</tt> ins Spiel. Es hat die gleiche Aufgabe wie <tt>%d</tt> oder <tt>%c</tt>, nur für Strings.
Sie werden gebeten, einen String einzugeben.
Dieser String wird danach in die Variable <tt>stri1</tt> kopiert.
Beide Strings, die ja nun die gleiche Zeichenkette enthalten, werden ausgegeben.

===strlen===
Die Funktion <tt>strlen</tt>, die als Parameter eine String-Variable erwartet, liefert die Länge dieses Strings zurück. Sie werden jetzt vermutlich sagen: "Das ist doch klar, wie lang der String ist. Ich habe es ja bei der Deklaratin angegeben". Das stimmt schon, aber denken Sie noch einmal an die null-terminierten Strings. Das 0-Zeichen steht am Ende des Strings (am Ende der gültigen Zeichenfolge), aber nicht unbedingt am Ende des reservierten Speicherplatzes. Haben Sie eine Variable "char Variable[21];", und ihr den Wert "hallo" zugewiesen, dann steht das null-Zeichen in Variable[5]. Der "gültige" String ist also 5 Zeichen (0-4) lang. Und genau das (5) würde strlen zurück liefern.

<pre>
#include <stdio.h>
#include <string.h>

int main (void)
{
char stri[21];

strcpy (stri, "hallo");
printf ("Der String ist %d Zeichen lang", strlen (stri));
}
</pre>

Diese Funktion wird vor allem gebraucht, wenn Sie direkt auf den String zugreifen, mittels <tt>stri[0]</tt>, <tt>stri[1]</tt>, etc.

==Ein- und Ausgabe-Funktionen==

===Bildschirm-Ausgabe===
Bisher war das Tutorial trotz aller Beispiele reine Theorie. Sie konnten zwar Programme schreiben, aber die Funktion nicht testen. Hier lernen Sie nun, wie Sie etwas am Bildschirm ausgeben.

Die dazu notwendige Funktione heisst <tt>printf</tt> (das '<tt>f</tt>' ist kein Fehler!). Diese Anweisung gibt die ihr übergebenen Parameter auf das Standard-Ausgabegerät aus, in der Regel also auf den Bildschirm. Sie kann beliebig viele Parameter übernehmen. Es müssen jedoch Standard-Datentypen (z.B. <tt>int</tt>, <tt>char</tt>, <tt>double</tt>...) sein!
<pre>
#include <stdio.h>

int main (void)
{
int zahl1 = 12;
char zeichen1 = 'A';

printf ("Das ist Text, und er wird als solcher ausgegeben. \n");
printf ("Der Wert der Variablen 'zahl1' ist: %d \n", zahl1);
printf ("Der Wert der Variablen 'zeichen1' ist: %c \n", zeichen1);
printf ("Der Wert der Variablen 'zeichen1' ist: %d \n", zeichen1);

return 0;
}
</pre>

Der erste <tt>printf</tt>-Befehl gibt Text aus. Das Zeichen am Ende (<tt>\n</tt>) bedeutet "New Line", es bewegt den Cursor an den Anfang der nächsten Zeile.

Der zweite <tt>printf</tt>-Befehl gibt auch Text aus, am Ende befindet sich wieder das <tt>\n</tt>, um einen Zeilenvorschub zu erreichen. Das <tt>%d</tt> wird vom Compiler durch den ersten Parameter ersetzt, der nach dem Text angegeben wird. In diesem Fall wird <tt>%d</tt> also durch den Wert der Variablen <tt>zahl1</tt> ersetzt. Das <tt>d</tt> im <tt>%d</tt> bedeutet "Dezimalzahl", der Computer gibt also eine ganze Zahl aus.

In der dritten Ausgabe wird ein Zeichen ausgegeben. Diesmal bedeutet <tt>%c</tt> "char" (Zeichen). Es wird also <tt>%c</tt> durch ein <tt>A</tt> ersetzt, denn die Variable <tt>zeichen1</tt> wird als Character interpretiert.

Die letzte Ausgabe interpretiert den Inhalt von <tt>zeichen1</tt> als Zahl, und gibt dager den ASCII-Wert von <tt>A</tt>, also 65 aus. Das ist ein typisches Beispiel für das mögliche unterschiedliche Interpretieren einer Variablen!

===Tastatur-Eingabe===

Um ein "gscheites" Programm schreiben zu können, muß man wissen, wie der Benutzer über die Tastatur Befehle eingeben kann. Die dafür notwendigen Funktionen stelle ich in diesem Kapitel vor.
Die wichtigste Funktion ist <tt>scanf</tt>. Er liest Daten von der Tastatur. Die Syntax entspricht derer von <tt>printf</tt>:

<pre>
int zahl1;
char zeichen1;

printf ("Bitte geben Sie eine Zahl ein: ");
scanf ("%d", &zahl1);
printf ("Geben Sie einen Zeichen ein: ");
scanf ("%c", &zeichen1);
</pre>

Das Programm gibt eine Eingabeaufforderung aus. Dann erwartet es vom Benutzer, daß er eine Zahl eingibt, die mit [ENTER] bestätigt wird. Dieser Wert wird in <tt>zahl1</tt> abgespeichert. Danach erfolgt wiederum eine Aufforderung zur Eingabe, diesmal eines einzelnen Zeichens. Dieses kann man nun eingeben und ebenfalls mit [ENTER] bestätigen.

Macht man keine dem Datentyp der erwarteten Variable entsprechende Eingabe, dann bricht das Programm mit einer Fehlermeldung ab (wenn man z.B. "1_T2" eingibt, wenn eine Zahl erwartet wird)!

Das <tt>&</tt> vor den Parametern ist notwendig. Warum, das erfahren Sie im Kapitel "Unterprogramme". Für die Profis eine Kurz-Erklärung: Das Unterprogramm <tt>scanf</tt> bekommt zwar einen Wert übergeben, kann aber keinen zurückliefern ("call by value"). Daher wird kein Wert, sondern ein Zeiger auf eine Variable übergeben. Mit dem & Zeichen bekommen Sie die Adresse einer Variablen ("call by reference").

=Parameter von <tt>main</tt>=
Das Unterprogramm "<tt>main</tt>" kann, wie jede andere Funktion, Parameter besitzen. Doch keine selbst gewählten, sondern nur bestimmte. Doch warum braucht main Parameter? Denken Sie einmal an alle Betriebssystembefehle:
<tt>dir *.exe </tt> oder <tt>copy *.* a:</tt> oder <tt>ls -la </tt>. All diese Befehle sind aus zwei Teilen aufgebaut: Befehl und Parameter. Und genau diese Parameter können Sie mit den <tt>main</tt>-Parametern abfragen.
<pre>
int main (int argc, char *argv[], char* environ[])
</pre>

Bei "<tt>argc</tt>" handelt es sich um eine normale int-Variable (engl. "''argument count''", "Parameter-Zähler"). In ihr steht die Anzahl der übergebenen Parameter. Die Parameter selbst folgen im zweiten Argument, das als Array von Strings übergeben wird. Das dritte Argument ist ein Array mit den Umgebungsvariablen. Seine Länge wird nicht explizit übergeben; nach dem letzten Element steht ein Null-String, also ein String der Länge 0. In dieser Array befindet sich auch der Inhalt der Umgebungsvariablen <tt>PATH</tt>, die den Suchpfad für ausführbare Programme enthält.
<pre>
#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[], char * environ[])
{
int i;

printf ("Es wurden %d Parameter angegeben", argc);

for (i=0; i < argc; i++)
printf ("Parameter %d: %s\n", i, argv[i]);

for (i = 0; environ[i] != NULL; ++i)
printf ("environ[%d] = %s\n", i, environ[i]);
}
</pre>

;Erklärung: Bei der ersten Ausgabe wird ausgegeben, wie viele Parameter insgesammt angegeben wurden. Dabei gibt immer mindestens einen Parameter, nämlich <tt>argc[0]</tt>. Dort steht der Name der aufgerufenen Datei selbst. Außerdem ist das letzte gültige Feldelement – wie in C üblich – das Element <tt>argv[argc-1]</tt>. In der for-Schleife werden alle Parameter, inklusive ihrer Nummer, ausgegeben. Experimentieren Sie mit den Parametern, um das System zu vertehen!

=Kurzreferenz=
==Syntax-Bausteine==

Die Erklärung des Aufbaus von C-Befehlen erfolgt neben einfachen Beispielen auch durch ihren prinzipellen Aufbau. In diesen Syntax-Beschreibungen finden sich immer wieder die gleichen Bausteine, die hier näher erklärt werden sollen. Falls Dir solch ein Syntax-Baustein begegnet, kannst Du ihn anklicken und kommst dann zu seiner Erläuterung.

In den Beispielen selbst gehören auch die spitzen Klammern zu dem Baustein (was daran zu erkennen ist, daß auch die Klammern eingefärbt sind). Die Klammern dürfen in einem konkreten C-Programm daher nicht eingetippt werden.

=====<tt><Bezeichner></tt>=====
Bezeichner in C dienen dazu, Variablen zu identifizieren und ihnen sprechende Namen zu geben, um die Quelle lesbarer zu machen. Man braucht Bezeichner auch, um selbstdefinierte Datentypen zu benennen und zum Benennen von Struct- und Union-Komponenten sowie als Namen für Funktionen und Sprungmarken (Labels).

Bezeichner dürfen aus den Kleinbuchstaben <tt>a</tt>...<tt>z</tt>, den Großbuchstaben <tt>A</tt>...<tt>Z</tt>, dem Unterstrich <tt>_</tt> und den Ziffern <tt>0</tt>...<tt>9</tt> aufgebaut werden, wobei an erster Stelle jedoch keine Ziffer stehen darf.

Es wird zwischen Groß- und Kleinschreibung unterschieden.

=====<tt><Ausdruck></tt>=====
Ein Ausdruck in C ist ein Konstrukt, das einen Wert hat. Ob dieser Wert eine ganze Zahl ist, eine Kommazahl oder ein Zeiger, etc. ist dabei egal. Die einfachsten Ausdrücke sind Konstanten wie
2
oder Variablen wie
ein_zahl
Mehrere Ausdrücke können durch [[#Liste der Operatoren|Operatoren]] zu komplexeren Ausdrücken kombiniert werden, etwa
eine_zahl + andere_zahl == 2
oder
eine_zahl = 2
Letzterer hat den Wert <tt>2</tt> und den Nebeneffekt, daß er diesen Wert an <tt>eine_zahl</tt> zuweist.

Auch der Aufruf einer Funktion, die einen Rückgabewert liefert, ist ein Ausdruck:
sin (1.2)
und kann zum Aufbau komplexerer Ausdrüche verwendet werden.

=====<tt><Bedingung></tt>=====
Eine Bedingung ist ein Ausdruck, bei der nur interessiert, ob dieser zu 0 (unwahr) auswertet oder zu ungleich 0 (wahr). Solche Ausdrücke findet man in if-Anweisungen, in Schleifenbedingungen und bedingten Zuweisungen
(ein_wert < 2) || (ein_wert > 40)

=====<tt><Lvalue></tt>=====
Ein Lvalue ist ein Ausdruck, dem etwas zugewiesen werden kann. Der Name ''Lvalue'' kommt aus dem Englischen. Das ''L'' steht abkürzend für left. Ein Lvalue ist damit ein Ausdruck, der auf der linken Seite eine Zuweisung in C stehen darf. Das <tt>x</tt> in den folgenden Beispiel-Ausdrücken muss ein Lvalue sein:
x = y-1

x++

=====<tt><Konstante></tt>=====
Eine Konstante ist ein Ausdruck, dessen Wert dem Compiler bekannt ist. Beispiele für Konstanten sind etwa
7
'B'
-13.98e12
1+(2*3)
und die Werte von [[#Enum|Enum]]s.

Das <tt>Pi</tt> aus dem folgenden Codestück definiert jedoch keine Konstante in diesem Sinne
const double Pi = 3.14159256;
denn in einem anderen Quellmodul könnte durch die Deklaration
extern const double Pi;
das Symbol <tt>Pi</tt> bekannt sein, ohne daß sein Wert bekannt ist!

=====<tt><Adresse></tt>=====
Eine Adresse ist ein Ausdruck, der einen Speicherort (physikalisch oder virtuell) halten kann. Adressen erhält man dadurch, daß man einem Bezeichner den Adress-Operator <tt>&</tt>voranstellt, Adressen durch Arithmetik berechnet oder Zahlen zu Adressen castet. Folgende Ausdrücke sind Adressen (eine sinnvolle Deklaration der auftretenden Variablen vorausgesetzt)
& eine_zahl
& ein_array[10]
& ein_struct
& ein_struct.komponente
(int *) 0x1234
(int *) eine_zahl

=====<tt><Deklaration></tt>=====

=====<tt><Anweisung></tt>=====
Anweisungen sind gewissermassen die Atome (oder Moleküle?), aus denen ein C-Programm besteht. Jedes C-Programm ist eine Abfolge von Deklarationen und Anweisungen. Einfache Anweisungen erhält man, in dem man einen Ausdruck nimmt und einen Strichpunkt dahinter schreibt:
{{Ausdruck|}};
wie in
x = x+1;

Andere Anweisungen sind die unten aufgeführten Schleifen und die if- sowie die switch-Anweisung.

Mehrere Deklarationen und Anweisungen können zu einem Block zusammengefasst werden. Dieser Block stellt dann wieder eine einzelne Anweisung dar und kann genau so gehandhabt werden!
{
{{Deklaration}}
{{Deklaration}}
...
{{Anweisung}}
{{Anweisung}}
...
}
In diesem Sinne ist auch z.B. die Syntax der if-Anweisung zu verstehen
if ({{Bedingung}})
{{Anweisung}}
besagt, daß der abhängig ausgeführte Code eine einzelne Anweisung sein darf oder eben ein kompletter Block oder die Verschachtelung mehrerer Blöcke etc.

Eine Anweisung kann auch "leer" sein, also nichts tun. Diese Anweisungen sind der leere Block
{
}
und der Strichpunkt
;
die man gelegentlich in Schleifen findet:
while (!timeout())
{}
oder hinter Sprungmarken, die sonst direkt vor einer schliessenden Blockklammer stünden:
{
...
goto ein_label;
...
{{Label|ein_label}}:;
}

Nicht jede Anweisung ist an jeder Stelle eines C-Programms erlaubt, so darf ein <tt>continue</tt> nut innerhalb einer Schleife stehen. Gleiches gilt für <tt>break</tt>, das aber auch innerhalb eines <tt>switch</tt> vorkommen darf.

=====<tt><Type></tt>=====
Dies steht für einen Datentyp. Es kann ein elementarer Typ sein wie <tt>int</tt> oder <tt>double</tt>, ein Zeiger darauf wie <tt>char*</tt> oder <tt>void*</tt>, und auch Qualifier enthalten wie das <tt>unsigned</tt> im Typ <tt>unsigned long long</tt>.

Zu den Typen gehören auch zusammengesetzte Datentypen wie Strukturen und Unions, mit <tt>typedef</tt> selbst definierte Typen und natürlich Zeiger darauf, wie aus dem Abschnitt [[#Datentypen|Datentypen]]:
* <tt>struct Person</tt>
* <tt>struct Person *</tt>
* <tt>data32_t</tt>
* <tt>enum Farben</tt>
und Zeiger auf Funktionen.

=====<tt><Parameterliste></tt>=====

Die Parameterliste bei einer Funktionsdefinition gibt an, wieviel Übergabeparameter sie bekommt, wie diese heissen und welchen Typs diese sind. Der prinzipielle Aufbau ist
{{Type}} {{Bezeichner}}, {{Type}} {{Bezeichner}}, ...
Falls die Funktion keine Parameter hat, dann ist die Parameterliste leer.

Hier als Beispiel die zweiparameterige Funktion <tt>produkt</tt>. Der erste Parameter heisst <tt>a</tt> und ist ein <tt>double</tt>. Der zweite namens <tt>b</tt> ist vom Typ "Zeiger auf double", der Inhalt <tt>*b</tt> ist also auch ein double.

'''Definition der Funktion:'''
double produkt (double a, double *b)
{
return a * (*b);
}
In älteren C-Quellen findet man noch eine andere Syntax für die Deklaration der Parameter, die aber heute praktisch nicht mehr verwendet wird:
'''alte Definition der Funktion:'''
double produkt (a, b)
double a, *b;
{
return a * (*b);
}

Um die Funktion bekannt zu machen, verwendet man eine Deklaration bzw. den Prototypen, der dem Compiler nur mitteilt, welche Parameter die Funktion bekommt und was sie zurückliefert. Für den Aufruf der Funktion muss der Compiler nur diesen Prototyp kennen, ''was'' die Funktion im Endeffekt macht und wie sie implementiert wurde ist egal, sie wird als BlackBox angesehen.

'''Prototyp der Funktion:'''
double produkt (double a, double *b);
Hier dürfen die Bezeichner auch fehlen:
double produkt (double, double*);

==if==
if ({{Bedingung}})
{{Anweisung}}

==if-else==
if ({{Bedingung}})
{{Anweisung}}
else
{{Anweisung}}

==for==
for ({{Ausdruck|1}}; {{Bedingung}}; {{Ausdruck|2}})
{{Anweisung}}
Eine for-Schleife entspricht folgendem Konstrukt. Dabei sind die drei Ausdrücke optional. Fehlt die Bedingung, dann wird diese als "wahr" angenommen. Die beiden anderen Ausdrücke wird man als Ausdrücke mit Nebeneffekt wählen wie z.B. <tt>x=0</tt> oder <tt>x=x-2</tt>.
{
{{Ausdruck|1}};

{{Label|_loop}}:
if ({{Bedingung}})
{{Anweisung}}
else
goto _break;

{{Label|_continue}}:
{{Ausdruck|2}};
goto _loop;

{{Label|_break}}:;
}
Die Labels <tt>_break</tt> und <tt>_continue</tt> entsprechen den Sprungzielen einer <tt>break</tt> bzw. <tt>continue</tt>-Anweisung innerhalb von <tt><Anweisung></tt>.

==do-while==
do
{{Anweisung}}
while ({{Bedingung}});

==while==
while ({{Bedingung}})
{{Anweisung}}

==switch==
switch ({{Bedingung}})
{
case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

case {{Konstante}}:
{{Anweisung}}
{{Anweisung}}
...

...

default:
{{Anweisung}}
{{Anweisung}}
...
}

=Liste der Schlüsselworte=
[[#Speicherklassen|<tt>auto</tt>]],
[[#break-Anweisung|<tt>break</tt>]],
[[#Elementare Datentypen|<tt>double</tt>]],
[[#Elementare Datentypen|<tt>char</tt>]],
[[#switch-Anweisung|<tt>case</tt>]],
[[#Konstanten|<tt>const</tt>]],
[[#continue-Anweisung|<tt>continue</tt>]],
[[#switch-Anweisung|<tt>default</tt>]],
[[#do-while-Schleife|<tt>do</tt>]],
[[#if-Anweisung|<tt>else</tt>]],
[[#Enum|<tt>enum</tt>]],
[[#Speicherklassen|<tt>extern</tt>]],
[[#Elementare Datentypen|<tt>float</tt>]],
[[#for-Schleife|<tt>for</tt>]],
[[#goto-Anweisung|<tt>goto</tt>]],
[[#Inlining|<tt>inline</tt>]],
[[#if-Anweisung|<tt>if</tt>]],
[[#Elementare Datentypen|<tt>int</tt>]],
[[#Elementare Datentypen|<tt>long</tt>]],
[[#return-Anweisung|<tt>return</tt>]],
[[#Speicherklassen|<tt>register</tt>]],
[[#Elementare Datentypen|<tt>short</tt>]],
[[#Elementare Datentypen|<tt>signed</tt>]],
[[#Liste der Operatoren|sizeof]],
[[#Speicherklassen|<tt>static</tt>]],
[[#Strukturen|<tt>struct</tt>]],
[[#switch-Anweisung|<tt>switch</tt>]],
[[#Eigene Datentypen|<tt>typedef</tt>]],
[[#Unions|<tt>union</tt>]],
[[#Elementare Datentypen|<tt>unsigned</tt>]],
[[#Elementare Datentypen|<tt>void</tt>]],
[[#Speicherklassen|<tt>volatile</tt>]],
[[#while-Schleife|<tt>while</tt>]]

=Liste der Operatoren=

{| {{Blauetabelle}}
|- {{Hintergrund2}}
!| Operator || Bedeutung
|- {{Hintergrund1}}
!colspan="2"|Arithmetische Operatoren
|-
|colspan="2"| Dies sind die "normalen" arithmetischen Operationen, wie man sie aus der Schule kennt. Man kann damit und allen anderen Operatoren auch komplexere Ausdrücke aufbauen. Die Prioritäten sind so, wie man sie kennt, also "Punktrechnung vor Strichrechnung". Will man dies ändern, dann mit den runden Klammern: 
<tt>1+2*3          </tt>→ 7 
<tt>(1+2)*3        </tt>→ 9 
|-
| <tt>{{Ausdruck|}} + {{Ausdruck|}}</tt> || Addition
|-
| <tt>{{Ausdruck|}} - {{Ausdruck|}}</tt> || Subtraktion
|-
| <tt>{{Ausdruck|}} * {{Ausdruck|}}</tt> || Multiplikation
|-
| <tt>{{Ausdruck|}} / {{Ausdruck|}}</tt> || Division
|-
| <tt>{{Ausdruck|}} % {{Ausdruck|}}</tt> || Rest der Division (modulo)
|-
| <tt>- {{Ausdruck|}}</tt> || Vorzeichenumkehr, Zweier-Komplement

|- {{Hintergrund1}}
!colspan="2"|Logische Operatoren und Vergleiche
|-
|colspan="2"|Die logischen und die vergleichenden Operatoren liefern als Ergebnis den Wert <tt>0</tt> (wahr) oder einen Wert ungleich <tt>0</tt> (falsch, um genau zu sein den Wert <tt>!0</tt>).

Man kann das Ergebnis zwar einer Variablen zuweisen, in aller Regel wird man solche Ausdrücke jedoch in Bedingungen zu <tt>if</tt> oder in Abbruch-Bedingungen von Schleifen finden.
|-
| <tt>{{Ausdruck|}} && {{Ausdruck|}}</tt> || logisches AND: beides wahr (ungleich 0)
|-
| <tt>{{Ausdruck|}} || {{Ausdruck|}}</tt> || logisches OR: mind. eines ist wahr (ungleich 0)
|-
| <tt>! {{Ausdruck|}}</tt> || logisches NOT (0 ↔ ungleich 0)
|-
| <tt>{{Ausdruck|}} == {{Ausdruck|}}</tt> || ist gleich
|-
| <tt>{{Ausdruck|}} != {{Ausdruck|}}</tt> || ist nicht gleich
|-
| <tt>{{Ausdruck|}} < {{Ausdruck|}}</tt> || ist kleiner
|-
| <tt>{{Ausdruck|}} <= {{Ausdruck|}}</tt> || ist kleiner oder gleich
|-
| <tt>{{Ausdruck|}} > {{Ausdruck|}}</tt> || ist größer
|-
| <tt>{{Ausdruck|}} >= {{Ausdruck|}}</tt> || ist größer oder gleich

|- {{Hintergrund1}}
!colspan="2"|Bitweise Operatoren
|-
| <tt>~ {{Ausdruck|}}</tt> || bitweise NOT (Einser-Komplement)
|-
| <tt>{{Ausdruck|}} & {{Ausdruck|}}</tt> || bitweise AND
|-
| <tt>{{Ausdruck|}} | {{Ausdruck|}}</tt> || bitweise ODER
|-
| <tt>{{Ausdruck|}} ^ {{Ausdruck|}}</tt> ||bitweise XOR
|-

|- {{Hintergrund1}}
!colspan="2"|Shift-Operatoren
|-
| <tt>{{Ausdruck|}} << {{Ausdruck|}}</tt> || Bits nach links schieben
|-
| <tt>{{Ausdruck|}} >> {{Ausdruck|}}</tt> || Bits nach rechts schieben

|- {{Hintergrund1}}
!colspan="2"|Typen
|-
|colspan="2"|Ein Cast in C kann dazu verwendet werden, den Typ eines Ausdruckes zu ändern oder den Ausdruck mit einer bestimmten Genauigkeit zu berechnen. Wird z.B. eine Berechnung standardmässig in 16 Bit ausgeführt, dann kann man mit einem Cast 
<tt>(long) ···</tt> 
ausdrücken, daß die Berechnung in 32 Bit erfolgen soll. Des weiteren kann man Zeiger und ganze Zahlen und Gleitkommazahlen ineinander umwandeln.

Casts können ''nicht'' dazu verwendet werden, um z.B. eine Zahl in einen String zu konvertieren, der diese Zahl darstellt! Dafür gibt es spezielle Funktionen wie <tt>itoa</tt>!
|-
| <tt>({{Type}}) {{Ausdruck|}}</tt> || Cast, Typwandlung
|-
|valign="top"| <tt>sizeof ({{Type}})</tt> || Eine Konstante, deren Wert die Größe (in Bytes) des Typs ist. <tt>sizeof</tt> ist auch auf Objekte anwendbar wie <tt>int</tt>, Arrays bekannter Größe, Strukturen und Unions, Array-, Struktur- und Union-Komponenten, Pointer, etc. Beispiel: 
int i, sum=0, array[] = { 1, -13, 4, 0, sizeof (int*) };

for (i=0; i< sizeof (array) / sizeof (array[0]); i++)
sum += array[i];
Alle Elemente des Arrays werden aufaddiert, ohne daß deren Anzahl explizit in der Schleife genannt ist.

|- {{Hintergrund1}}
!colspan="2"|Zeiger und Adressen
|-
| <tt>* {{Adresse}}</tt> || der Inhalt an Adresse
|-
| <tt>& {{Lvalue}}</tt> || Adresse von

|- {{Hintergrund1}}
!colspan="2"|Strukturen, Unions, Arrays
|-
| <tt>{{blau|<Struct>}}.{{Bezeichner}}</tt> || Komponente einer Struktur/Union
|-
| <tt>{{blau|<Zeiger-auf-Struct>}} -> {{Bezeichner}}</tt> || Komponente einer Struktur/Union, deren Adresse man hat
|-
| <tt>{{Adresse}}[{{Ausdruck|}}]</tt> || Array-Element

|- {{Hintergrund1}}
!colspan="2"|Bedingte Auswertung
|-
| <tt>({{Bedingung}}) ? {{Ausdruck|}} : {{Ausdruck|}}</tt> || Auswahl des Wertes abhängig von der Bedingung

|- {{Hintergrund1}}
!colspan="2"|Zuweisung und Operatoren mit Nebeneffekt
|-
|colspan="2"|Die Unterschiede der post- und pre-Varianten der Increment/Decrement kommen in Konstrukten wie <tt>x = *p++</tt> zum tragen:
<tt>x = *p++;       </tt>→ <tt> x = *p; p = p+1;</tt> 
<tt>x = *++p;       </tt>→ <tt> p = p+1; x = *p;</tt> 
<tt>x = (*p)++;     </tt>→ <tt> x = *p; *p = (*p)+1;</tt> 
<tt>x = ++(*p);     </tt>→ <tt> *p = (*p)+1; x = *p;</tt>
|-
| <tt>{{Lvalue}} = {{Ausdruck|}}</tt> || Zuweisung
|-
| <tt>++ {{Lvalue}}</tt> || Pre-Increment
|-
| <tt>-- {{Lvalue}}</tt> || Pre-Decrement
|-
| <tt>{{Lvalue}} ++</tt> || Post-Increment
|-
| <tt>{{Lvalue}} --</tt> || Post-Decrement

|- {{Hintergrund1}}
!colspan="2"|Kurzschreibweisen
|-
|colspan="2"| Für ganz Faule gibt es anstatt 
<tt>a = a @ b</tt> 
für viele Operatoren (hier dargestellt durch ein <tt>@</tt>) die abkürzende Schreibweise 
<tt>a @= b</tt>
|-
| <tt>{{Lvalue}} += {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} -= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} *= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} /= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} %= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} ^= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} &= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} | {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} <<= {{Ausdruck|}}</tt> ||
|-
| <tt>{{Lvalue}} >>= {{Ausdruck|}}</tt> ||
|}

= Autoren=
* Plasma
* Bernd
* [[Benutzer:SprinterSB|SprinterSB]]

=Quellen=
* Kernighan und Ritchie
* Christian Wirth, C-Tutorial
* Prof. Dr. J. Dankert Ausführungen
* W. Alex, Einführung in C/C++
* Peter Baeumle-Courth, ANSI-C im Überblick

=Siehe auch=
* [[C-Tutorial/Interrupt-Programmierung]]
* [[avr-gcc]]
* [[Compiler]]
* [[WinAVR]]
* [[Fallstricke bei der C-Programmierung]]
* [[Code::Blocks]]
* [[Installationsanleitung_von_avrlib]]

=Weblinks=
* [http://www.uni-bayreuth.de/departments/math/~rbaier/lectures/c_ss2002/html/html.html C-Tutorial Uni Bayreuth]
* [http://wwwuser.gwdg.de/~kboehm/ebook/inhalt.html C-Programmieren unter Linux]
* [http://www.gdv.uni-hannover.de/documentation.php Skripte zum Selbststudium: C, C++, Java, etc]
* [http://info.baeumle.com/ansic.html Einführung in ANSI-C]

[[Kategorie:Quellcode C|!]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]

Diskussion:Code::Blocks

2009-12-13T12:46:45Z

RobotProgger:

== Löschdiskussion ==
'''Behalten'''. Da Dev-CPP nicht mehr weiterentwickelt wird, sollte man diesen Artikel unbedingt behalten und erweitern! Ich werde ihn mir vorknöpfen. --[[Benutzer:RobotProgger|RobotProgger]] 13:46, 13. Dez 2009 (CET)--

Dev-Cpp IDE

2009-12-13T12:45:14Z

RobotProgger:

<div style="margin:1em; padding:1em; border:solid 2px #FF0040;">

Zitat aus Wikipedia:

"Die letzten Arbeiten an Dev-C++ wurden im März 2005 veröffentlicht. An dem Status der letzten zugänglichen Beta-Version hat sich seitdem nichts verändert, man geht deshalb davon aus, dass die Arbeiten an diesem Projekt eingestellt wurden." (Stand 12/2009) --[[Benutzer:RobotProgger|RobotProgger]] 13:45, 13. Dez 2009 (CET)----
</div>

Irgendwann beginnt jeder der Mikrocontroller wie die AVRs in C/C++ programmiert sich Gedanken zu machen, ob es nicht eine komfortable IDE gibt, die das Programmers Notepad von [[WinAVR]] ersetzt. Es gibt eine entsprechende IDE die unter der GPL steht und damit kostenlos ist: Dev-Cpp. 
Dieser kleine Artikel soll in kurzen Sätzen erläutern, wie man sich die IDE so einrichtet, dass man wie gewohnt nur mit mehr Komfort arbeiten kann. Außerdem soll er auch eine kleine Einführung in Dev-Cpp sein.

== Was ist eine IDE? ==
IDE steht für integrierte Entwicklungsumgebung. Sie fassen viele Programmierwerkzeuge zusammen (wie z.B. einen Compiler, einen komfortablen Texteditor, Versionsverwaltung, et cetera). Dadurch entfallen viele lästige Aufgaben, weil diese die IDE übernimmt.

== Dev-Cpp ==
Dev-Cpp ist eine C/C++ Entwicklungsumgebung die unter der GPL steht und damit kostenlos im Web zu haben ist (siehe Weblinks).

=== Einrichten ===
Nach erfolgreicher Installation sollte die IDE ohne Probleme starten. Neben der IDE muss auch noch [[WinAVR]] installiert sein. 
Um nun Dev-Cpp einzurichten geht man so vor. 
* Klicke auf ''Werkzeuge » Compiler Optionen''.
[[Bild:DevCpp_Werkzeuge.png|Dev-Cpp]]

* Als nächstes ein neues Compiler Set anlegen. Gebt ihm einen beliebigen Namen wie z.B. avr-gcc. Ihr könnt ihn später auch noch umbenennen. Wenn man weitere Projekte anlegt, kann man dann einfach dieses Set auswählen.
[[Bild:DevCpp_Compiler_neu.png|Dev-Cpp]]

* Dann im gleichen Fenster auf den Reiter ''Programme'' klicken und dort alles entsprechend dem Bild unten ändern (die Zeilen die geändert werden müssen sind blau hinterlegt). Dann den Dialog über ''OK'' schließen.
[[Bild:DevCpp_Compiler_avrgcc.png|Dev-Cpp]]

* Zum Schluss musst Dev-Cpp noch so eingestellt werden, dass es euer Makefile (am besten mit MFile erzeugen) verwendet. Erstellt dazu erst ein neues Projekt über ''Datei » Neu » Projekt...''.
[[Bild:DevCpp_NeuesProjekt.png|Dev-Cpp]]

* Klickt nun auf ''Projekt » Projekt Optionen'' und im Fenster dann auf den Reiter Make. Dort setzt ihr den Haken vor ''Nutze eigenes Makefile (kein Makefile generieren)'' und wählt dann euer Makefile aus indem ihr auf den Button rechts klickt. Hier ist eine kleine Tücke zu beachten. Damit Dev-Cpp das Makefile verwendet, muss dieses in dem gleichen Verzeichnis wie die Projektdatei liegen, sonst nimmt Dev-Cpp das Makefile nicht an!
[[Bild:DevCpp_Make.png|Dev-Cpp]]

Das war es dann auch schon. 
Nun eine kleine Einführung in Dev-Cpp.

=== Eine kleine Einführung ===
Möchte man mit Dev-Cpp arbeiten, so muss am zuerst einmal ein neues Projekt erstellen, indem man auf ''Datei » Neu » Projekt...'' klickt. Dort wählt man Projekttyp Console Application, wählt unten rechts die entsprechende Programmiersprache aus und gibt einen Projektnamen ein. 
Nun speichert man das Projekt und dann kann es auch schon fast losgehen. Als letzes muss das Projekt (wie oben beschrieben) noch kurz auf den avr-gcc und eigenes Makfile eingestellt werden. Siehe dazu die Beschreibung oben. 
Neue Dateien kann man dem Projekt über ''Projekt » Zum Projekt hinzufügen'' hinzufügen, oder über ''Projekt » Neue Datei'' überhaupt eine neue Datei erstellen. 
Links oben unter dem Reiter '''Projekt''' findet man alle Projekte. Unter dem Reiter '''Klassen''' findet man zum jeweiligen Projekt die Klassen und deren Methoden oder nur C-Funktionen. 
Außerdem findet man unter den Reitern am unteren Bildschirmrand wichtige Ausgaben.

==== Codevervollständigung ====
Dev-Cpp bietet eine Codevervollständigung an. Wenn man immer die gleichen langen Funktionsnamen eingeben muss, ist diese ein großer Vorteil. Man gibt einfach ein paar Anfangsbuchstaben des Funktionsname ein und drückt dann Strg + Enter und schon popt ein Popup auf, in dem man zwischen den möglichen Funktionen wählen kann.

==== Werzeuge ====
Unter Dev-Cpp ist es möglich ähnlich dem ProgrammersNotepad von [[WinAVR]] eigene Werkzeuge einzubinden (also z.B. Programme, die mit speziellen Parametern aufgerufen werden sollen). 
Unter ''Werkzeuge » Konfiguriere Werkzeuge'' kann man sich seine eigenen Werkzeuge kreieren und diese ändern. Diese kann man dann im Menü ''Werkzeuge'' aufrufen.
[[Bild:DevCpp_Eigene_Werkzeuge.png|Dev-Cpp]]

==== Konfiguration ====
Dev-Cpp lässt sich in vielen Bereichen weit konfigurieren. 
Den '''Editor''' konfiguriert man unter ''Werkzeuge » Editor Optionen''. Dort kann man z.B. einstellen, dass Zeilennummern angezeigt werden werden und man kann das Tabverhalten bestimmen (beides auf jeden Fall zu empfehlen). 
Die '''IDE''' an sich konfiguriert man unter ''Werkzeuge » Umgebungs Optionen''. Dort kann man z.B. die Sprache oder das Aussehen der IDE bestimmen. 
Der '''Compiler''' wird unter ''Werkzeuge » Compiler Optionen'' konfiguriert.

==== Wichtige Tastenkürzel ====
Die wichtigsten Tastenkürzel auf einen Blick. Man kann die Tastenkürzel (auch Shortcuts genannt) unter ''Werzeuge » Konfiguriere Shortcuts'' ändern. 

{| {{Blauetabelle}}
|- {{Hintergrund1}}
! colspan="2"| Ausführen
! colspan="2"| Datei
! colspan="2"| Suchen/Ersetzen
|-
|Kompilieren
|Strg + F9
|Neu
|Strg + N
|Suchen
|Strg + F
|-
|Ausführen
|Strg + F10
|Speichern
|Strg + S
|Ersetzen
|Strg + R
|-
|Alles erneuern
|Strg + F11
|
|
|Gehe zu Zeile
|Strg + G
|-
|
|
|
|
|Gehe zu Funktion
|Strg + Shift + G
|} 

Weitere wichtige Tastenkürzel sind: 
* '''Strg + Pos1'''/'''Strg + Ende''': An den Anfang bzw. das Ende der Datei springen.
* '''Strg + Pfeiltasten oben/unten''': Scrollen, Cursur bleibt in Zeile stehen.
* '''Shift + Pfeiltasten links/rechts''': Einzelne Zeichen selektieren.
* '''Shift + Pos1'''/'''Shift + Ende''': Ganze Zeile selektieren.

== Bemerkung ==
Es soll hier auch Rande erwähnt sein, dass es auch andere C/C++ IDEs gibt – u.a. CDT in Verbindung mit Eclipse. Allerdings ist die Konfiguration dieser IDE viel aufwändiger und ich habe es noch nicht geschafft sie zum laufen zu bringen. Wer Lust hat und weiß wie man CDT richtig einrichtet, kann ja hier einen Artikel verfassen. Außerdem habe ich auch von CodeBlocks gehört. Man sieht es gibt IDEs wie Sand am Meer.

== Weblinks ==
* http://www.bloodshed.net/

== Siehe auch ==
* [[WinAVR]]
* [[avr-gcc]]

 
--[[Benutzer:Luma|Luma]]

[[Kategorie:Microcontroller]]
[[Kategorie:Praxis]]
[[Kategorie:Software]]

Buchvorstellungen

2009-03-16T10:07:02Z

RobotProgger: /* C Programmieren von Anfang an, Autor Helmut Erlenkötter */

http://www.roboternetz.de/wiki/uploads/Main/buchvorstellungen.jpg

==Robotik-Bücher==
===Grundlagen der Robotertechnik, Autor Heinz W. Katzenmeier===

Ein wirklich gutes Buch für echte Bastler. Am meisten werden sicherlich Roboter-Einsteiger von dem Buch profitieren, zumal auch Grundlagen wie Materialkunde, Bauformen, Einheiten-Tabellen und ein wenig Elektronik-Grundlagen angesprochen werden. Aber auch erfahrene Bastler werden eine ganze Menge Anregungen und Tipps in dem Buch finden.

Der Themenschwerpunkt des Buches liegt eindeutig im Bereich Mechanik und Konstruktion. Hier findet man praktische Tips, z.B. wie man aus Silikonkitt Silikonringe für den Antrieb bastelt. Wer kommt schon auf die Idee, Silikon auf einer Wasseroberfläche aufzutragen, um Silikonringe herzustellen?

Auch seltsame Roboter-Konstrukte, in Ball- oder Walzenform, werden beschrieben. Natürlich fehlen auch nicht die Krabbelkonstrukte mit mehreren Beinen und die herkömmlichen 3-Rad-Roboter.
Viele Roboterkonstruktionen kommen ganz ohne Elektronik aus, können jedoch trotzdem Hindernissen ausweichen. Dazu hat der Autor die seltsamsten Konstrukte und Mechaniken entworfen. Die Fotos sind leider alle in Schwarzweiss, ein bisschen mehr Farbe wäre wünschenswert. Aber die große Anzahl an verständlichen Zeichnungen machen während des Lesens die fehlenden Farbfotos wieder wett.

Der Autor geht bei seinen Konstruktionen recht einfache und leicht nachzubauende Wege, was insbesondere Mechanik-Neulinge erfreuen dürfte. So wird z.B. bei einem Getriebe der Motor einfach mit Heißkleber an einer Achse befestigt. Oder ein bisschen Papier zwischen den Zahnrädern sorgt dafür, dass diese nicht zu straff ineinander greifen. ''Also jede Menge praktischer Tips.''

Einziger Mangel ist das Thema Elektronik. Außer einer Transistor-, Relais- oder Spannungsregler-Schaltung findet man kaum was in dem Buch. Ganz zu schweigen von Microcontrollern, diese wurde im Buch ganz ausgeklammert.

Dennoch finde ich das Buch sehr lesenswert. Denn gerade mit Elektronik versierten Bastlern fehlen manchmal ein wenig Kenntnisse und Ideen zur Mechanik. Das Buch fördert einfach das Verständnis für die mechanischen Grundlagen. Es stellt einfache und funktionierende Systeme vor, welche die eigene Fantasie anregen und durch ein schnell eintretendes Erfolgserlebnis zu weiteren kreativen Versuchen inspirieren. Insbesondere in Verbindung mit einem Mikrocontroller können daraus interessante Sachen entstehen.

<center>
http://images-eu.amazon.com/images/P/3895761478.03.MZZZZZZZ.jpg
</center>

Autor: Heinz W. Katzenmeier
231 Seiten
Format 17 x 23,5 cm (kartoniert)
€ 34,80 (D) / € 35,80 (A) / sFr 59,90
ISBN 3-89576-147-8

--[[Benutzer:Frank|Frank]] 18:04, 16. Nov 2005 (CET)

----

===Reinigungsroboter selbst gebaut, Autor Heinz W. Katzenmeier===

'''Klappentext:''' Robotertechnik ist in den letzten Jahren zunehmend in den Blick der Öffentlichkeit geraten. Nicht zuletzt aufgrund der immer häufiger werdenden Anwendungen im industriellen Bereich, im Spielzeugsektor und auch im Haushalt. Robotertechnik als Hobby ist besonders interessant und stellt eine außergewöhnliche Herausforderung dar, da dieses Hobby Fachgebiete wie Elektronik, Mechanik und Informatik verbindet. Es fördert daher in hohem Maße die Fähigkeit, vernetzt zu denken und komplexe, voneinander abhängige Sachverhalte zu erkennen.

Roboter-Wettbewerbe – wie zum Beispiel die alljährlich ausgetragene Roboter-Fußball-Weltmeisterschaft – sind ein besonderes Highlight, übersteigen allerdings in den meisten Fällen die Möglichkeiten eines Hobbyisten bei weitem. Andererseits ist der Aufbau eines vorgefertigten Bausatzes oder gar der Betrieb eines fertigen Roboters keine echte Herausforderung und wird schnell langweilig, zumal diese Roboter in der Regel auch keine realen Aufgaben erfüllen können. Besonders beeindruckend ist es, wenn ein Roboter sich nicht nur mehr oder weniger geschickt umher bewegt, sondern dabei gleichzeitig noch das Zimmer reinigt.

Dieses Buch stellt verschiedenste Möglichkeiten zum Selbstbau von Reinigungsrobotern vor; angefangen von einfachen mechanisch gesteuerten Wischrobotern bis hin zu komplexen, mikroprozessorgesteuerten Saugrobotern mit diversen Varianten der Hinderniserkennung. Dabei legt der Autor besonderen Wert auf die einfache und preiswerte Herstellung funktioneller Roboter.

[[Bild:buch_reinigungsroboter.jpg|center]]

'''Persönliche Meinung nach dem Lesen: '''Wer so fasziniert von dem Bau des perfekten Reinigungsroboters / [[Staubsaugerroboter]] ist, freut sich natürlich besonders, wenn er diesen Titel liest. Besondere Bewunderung verdient der Autor und Verlag, dass sie es wagen für die doch recht begrenzte Interessentengruppe ein eigenes Buch aufzulegen. Und in der Tat, es ist ein Buch, das sich von der ersten bis zur letzten Seite mit der Konstruktion von Reinigungsrobotern beschäftigt. Also auf Seitenfüller oder Werbung für kommerzielle Staubsaugerprodukte, wie man das manchmal in solchen Werken vorgesetzt bekommt, wurde verzichtet. Dass der Autor was von Robotern versteht und selbst ein Bastler ist, das ist ja schon von seinem Werk "Grundlagen der Robotertechnik" bekannt. Auch in diesem Buch steht eindeutig die Mechanik und Saugtechnik im Vordergrund, die Elektronik wird nahezu komplett ausgespart. Dies ist aber nicht weiter schlimm, denn zur Elektronik gibt es ja hier im Wiki oder im Roboternetz schon reichlich an Infos und geeigneten [[:Kategorie:Projekte|RN-Board-Bauanleitungen]], die verwendet werden könnten. Die große Schwierigkeit ist immer die Mechanik, und hier kann der Autor mit seinen Skizzen und Bildern gute Anregungen geben. Die Beschreibungen sind sehr einfach gehalten und richten sich nicht an Ingeneure, sondern an Bastler mit herkömmlichemn Technik-Verständnis. Dabei verwendet der Autor Bauelemente, die einfach zu beschaffen sind. Manchmal hätte man sich allerdings hier und da eine etwas ausführlichere und etwas professionellere Darstellung gewünscht. Eine große Kritik geht vor allem an den Verlag; viele Bilder sind nicht nur sehr klein, sondern alle Bilder sind auch Schwarzweiss gedruckt, teils auch nicht gerade sehr scharf. Ein Buch, das Anregungen zum Basteln geben soll, lebt auch von Bildern, hier wäre es unbedingt angebracht gewesen größere Farbbilder hinein zu bringen, damit man auch Details erkennen kann. Da es ja nun auch nicht gerade ein billiges Taschenbuch ist, kann man die Schwarzweiss-Bilder in solch einem Werk nicht verstehen.
Trotz aller Begeisterung über das Buch muss man sagen, dass sich Bastler, die sich schon sehr viel mit dem Thema beschäftigt haben, nicht allzuviel Neues erfahren, insbesondere im Hinblick auf Nachbau. Allerdings ist es auch immer schön, wenn man merkt, dass eigene Erfahrungen auf so manchen Seiten auch von professioneller Seite bestätigt werden. Zudem sind im Buch sehr viele Formeln und Tabellen enthalten, die beim Bau eines Reinigungsroboters nützlich sein können. Wie man bestimmte Sachen, wie Saugleistung messen oder vergleichen kann, ohne ein Messlabor zu haben, wird natürlich auch dargestellt.
'''Fazit:'''Für jemanden, der sich mit dieser Materie beschäftigt, ein Buch, das man einfach haben muss, auch wenn die Bilder verbesserungswürdig sind.
--[[Benutzer:Frank|Frank]] 10:19, 27. Jun 2006 (CEST)

Autor: Heinz W. Katzenmeier
Taschenbuch - 223 Seiten
Bezug: Amazon
Verlag: Elektor
Erscheinungsdatum: 19. Juni 2006
Auflage: 1
€ 34,80 (D) / € 35,80 (A) / sFr 59,9
ISBN: 3895761664

----

===Robotergreifer, Autoren S. Hesse, G.J. Monkman, R. Steinmann, H. Schunk===

Mit dem Greifer wird die Verbindung zwischen einem Objekt und der Maschine hergestellt. Greifertechnik gehört daher zum Kernwissen in der Handhabungs- und Robotertechnik. Dieses Buch macht den Leser mit den Grundlagen dieser Technik vertraut. Da viele Bücher zur Robotertechnik nur sehr begrenzte Aussagen zum Greifer machen, wird in diesem Werk erstmals eine umfassende Darstellung mit dem Charakter eines Nachschlagewerkes geboten. Das Buch enthält etwa 500 Strichzeichnungen zur Greifertechnik und -anwendung. Dabei legen die Autoren Wert auf eine möglichst vollständige Abhandlung aller wichtigen Aspekte: Prinzipien, Bauformen, Kinematik, Steuerung, Sensorik, Wechselvorrichtungen, Sicherheit und Anwendungen.

Dieses Buch richtet sich nicht unbedingt an den Modellbauer oder Bastler erster kleiner autonomer Roboter, das merkt man schon ein wenig am Verkaufspreis. Wer sich aber eingehender auch mit Industrierobotern oder den mechanischen Grundkonzepten einer "Roboterhand" auseinandersetzen will oder muss, der findet in diesem Buch wirklich reichlich an Informationen. Vorbildlich ist wirklich die didaktische Aufbereitung des Werkes. Leicht verständliche Skizzen und Diagramme, fast auf jeder Seite, erleichtern den tiefen Einblick in diese doch ungeahnt vielseitige Materie.

Beschrieben werden unter anderem die verschiedenen Greiferklassen, Bauformen, ein geschichtlicher Rückblick in Sachen Greifer, Greifersenorik, Handachsen und Kinematik und praktisch angewandte Greiferanwendungen.

Über den Autor
Dr.-Ing. habil. Stefan Hesse ist Konstrukteur, hält Vorlesungen am FH Technikum Wien und ist seit vielen Jahren als Herausgeber, Autor bzw. Coautor selbstständig tätig. Prof. Gareth Monkman ist als Hochschullehrer an der FH Regensburg im Studiengang Elektrotechnik/Mechatronik tätig und durch viele Fachaufsätze und Vorträge international bekannt. Ralf Steinmann ist Leiter Vertrieb und Marketing Automation bei der SCHUNK GmbH & Co. KG, Obersulm. Dipl.-Wirtsch.-Ing. Henrik Schunk ist Geschäftsführer der SCHUNK Intec Inc., Raleigh-Morrisville (USA).

Erschienen im Hanser Verlag Januar 2005
ISBN 3-446-22920-5
Bezug. z.B. Amazon
79 Euro

<center>
http://images-eu.amazon.com/images/P/3446229205.03._BO01,224,223,220_PIsitb-dp-arrow,TopRight,22,-21_SH30_SCMZZZZZZZ_.jpg
</center>

----
===Embedded Robotics von Tilo Gockel, Rüdiger Dillmann===

'''Klappentext (Buchrückseite)'''
Das Thema Robotik ist so aktuell wie niemals zuvor, das zeigen nicht nur modernste Industrieanwendungen, das zeigt auch die zunehmende Anzahl von Lehrveranstaltungen an Schulen und Hochschulen, von Forschungsprogrammen und Interessengemeinschaften.

Leider wird der Zugang zu diesem Forschungsbereich nicht immer leicht gemacht. Wie kann man auch einfach und einprägsam solch komplexe Inhalte wie Drehzahlregelung, Lageregelung, Bahnplanung, Aktuatorik und Sensorik, Kognition im Allgemeinen und Bildverarbeitung im Besonderen vermitteln? Zusammen mit den Grundlagen zur zugehörigen Hardware und Programmierung? Und dies noch auf einem bezahlbaren und reproduzierbaren, transparenten Basissystem? Mit kostenfrei zugänglichen Software-Entwicklungswerkzeugen?

Dass es möglich ist, zeigt vorliegendes Buch.

Die Autorenschaft setzt sich zusammen aus Mitarbeitern des Institutes für Technische Informatik von Herrn Prof. Dr.-Ing. Rüdiger Dillmann (ITEC, Universität Karlsruhe (TH)), die in zahlreichen Forschungs- und Industrieprojekten umfangreiche Erfahrungen im Bereich Robotik sammeln konnten und auch in der Lehre über die Jahre hinweg gelernt haben, dieses Wissen weiterzugeben.

Entstanden ist ein Buch, welches sowohl den interessierten Laien als auch den Fachmann anspricht. Die verwendete Mikrocontroller- und Mechanikplattform ermöglicht einen schnellen, robusten und kostengünstigen Aufbau der Experimente. Die zu Grunde liegende Methodik wird auf eine Art und Weise vermittelt, die eine Portierung auf komplexere Systeme einfach macht.

Aus dem Inhalt: Im vorliegenden Buch behandelt werden u.a. Grundlagen zu Mikrocontrollern (Entwicklungs-Toolchain, serielle Kommunikation usw.), Aktuatoren, Sensoren (LDRs, PSDs, optische Maus, Digitalkamera ...), Drehzahl- und Lageregelung, Bahnplanung, reflexbasiertes Verhalten, Subsumptionsnetzwerke, Bildverarbeitung und Realtime-Multitasking.

----

'''Persönliche Meinung nach dem Lesen:'''
Nach Lesen des Klappentextes hatte ich den Eindruck ein ideales Buch auch für Robotik-Bastler zu bekommen. Leider wird das Buch diesem Bereich nur zum Teil gerecht. Sehr gut gelungen sind die komplexeren Aufgabenstellungen, hier zeigt sich das fundierte Wissen der Autoren (Gockel/Dillmann).
Besonders gefallen haben mir die Bereiche wie Regelungstechnik, Drehzahlregelung, Servo-Ansteuerung, Bildverarbeitung, Schnittstellenbeschreibung und einige mehr. Jedoch dem Untertitel Praxisbuch wird es nur gerecht, wenn man ein spezielles Board von Elektor mit einem 8051-Controller nutzt. Alle Beispiele beziehen sich auf dieses Board bzw. diesen Controller. Leider wird dieser Controllertyp im Hobbybereich nicht mehr so häufig verwendet, wodurch viele Informationen im Buche, wie Controllerbeschreibung, Compilerbeschreibung, Beispiele, Librarys etc. nur für Besitzer dieses Controllertyps von Interesse sein dürften. Auch der Bereich Mechanik wird praktisch kaum in dem Buch angesprochen. Sehr hilfreich sind zum Teil die Links, die in einzelnen Kapiteln zu finden sind, allerdings hat man hier den Eindruck, dass das Linkarchiv zum Teil etwas älter ist.
'''Fazit:''' Ein ideales Buch für Besitzer eines 8051-Controllers und ein hilfreiches Buch für fortgeschrittenere Bastler, die sich intensiver mit einzelnen Thematiken, wie Drehzahlregelung, Bildverarbeitung und anderen Schwerpunkten, beschäftigen. Weniger hilfreich ist es für Einsteiger, die mit anderen Controllern arbeiten, erste Experimente machen oder in Basic programmieren wollen.
--[[Benutzer:Frank|Frank]] 18:07, 16. Nov 2005 (CET)

Erschienen Elektor-Verlag
Erscheinungsdatum: 2005
ISBN 3895761559
Bezug, z.B. Amazon
39,80 Euro

<center>
http://images-eu.amazon.com/images/P/3895761559.01.MZZZZZZZ.jpg
</center>

----

===Roboter Geschichte-Technik-Entwicklung, von Daniel Ichbiah===
'''Klappentext:''' Diener der Menschen

Die 1980er waren das Jahrzehnt des Computers, die 1990er das des Internets, die erste Dekade des 21. Jahrhunderts wird die der Roboter sein. In den USA, Japan und Europa kommt die Entwicklung von Robotern für alle Lebensbereiche immer mehr in Schwung. Den Weg dazu bahnten Science-Fiction-Schriftsteller, Filmemacher und Erfinder von Video-Spielen. Innerhalb der privaten Haushalte - angefangen von Kinderspielzeugen bis hin zu Staubsaugern, die selbständig ihre Arbeit verrichten - haben sich Roboter sanft, aber nachhaltig durchgesetzt. In der Medizintechnik sind sie nicht mehr wegzudenken, wenn es darum geht, Mikro-Operationen durchzuführen. Und auf dem Mars sind es selbstverständlich Roboter, die Missionen ausführen, die für ihre menschlichen Erfinder unmöglich wären.

Dieses reich illustrierte Buch spannt den Bogen von der verborgenen Mechanik in altägyptischen Götterstatuen über die Automaten und Androiden in Literatur und Film bis hin zu den Robotern in Industrie und Forschung. Der Fachjournalist und Roboterexperte Daniel Ichbiah erzählt in vielen Beispielen von Geschichte, Technik und Einsatz dieser faszinierenden Kreationen, die vom uralten Wunsch des Menschen zeugen, sich das Leben zu erleichtern.

Erschienen Knesebeck Verlag
Flexicover, 19 x 23 cm, 544 Seiten
Mit über 1.400 farbigen Abbildungen
Preis 35,00 €
ISBN 3896602764
Erscheinungstermin April 2005
Bezug u.a. Amazon

<center>
http://images-eu.amazon.com/images/P/3896602764.03.MZZZZZZZ.jpg
</center>

[[Bild:rnbuchvorstellungroboter.jpeg|thumb|600px|center|Einige EInblicke in das Buch]]

'''Persönliche Meinung zum Buch:''' Kein Buch, das Robotikbastlern Fachwissen vermittelt, sondern vielmehr ein Buch, das sich einfach an interessierte Leser (auch Techniklaien) wendet. Eigentlich eine Art illustriertes Bilderbuch zum Thema Entwicklungen der Robotik. Beim ersten Blick erinnert das dreispaltige Layout mit den vielen Bildern ein wenig an ein gutes Lexikon. Zwar ist es kein Nachschlagewerk, aber auch nicht gerade ein Buch, das man von vorne bis hinten Seite für Seite durchliest, dafür sind die Themenbereiche dann doch zu unterschiedlich. Es werden Entwicklungen bei den Spiel-, Staubsauger-, Haushalts-, Medizin-, Raumfahrt-, Meeresrobotern usw. aufgezeigt. Es wird über Roboter in Literatur, Film und Spielen berichtet, halt über alles, was man mit dem Begriff Roboter verbinden kann oder über was schon mal in den Medien berichtet wurde. Dabei beeindrucken vorwiegend die großen seitenfüllenden Bilder, die in bester Qualität abgedruckt wurden. Wer den Bereich der Robotik schon ein wenig verfolgt hat, wird leider sehr viele Bilder und Themenbereiche von zahlreichen Presseveröffentlichungen kennen. Kurze Texte und Interviews zwischen den Bildern vermitteln den derzeitigen Stand und die Zukunftsperspektiven des jeweiligen Bereiches aus Sicht von Wissenschaftlern oder Unternehmen.
Alles in allem ein Buch, das für technisch begeisterte Leser gedacht ist, die einfach einen Rundumblick für den Bereich ROBOTIK in einem Buch gebündelt im Regal stehen haben wollen. Bastler und Modellbauer, die vielleicht tiefergehende Tips, Technikgrundlagen und anwendbares Wissen für ihr Hobby erwarten, werden hier sicher nicht fündig. Bestenfalls kann das eine oder andere Bild Anregungen liefern mit welchen Themen man sich etwas mehr beschäftigen könnte. Aber das war ja auch nicht das Ziel des Buches.

--[[Benutzer:Frank|Frank]] 23:35, 30. Nov 2005 (CET)

----

===Roboter selbst bauen von Ulli Sommer===

'''Klappentext (Buchrückseite)'''
Roboter zu bauen wurde in den letzten Jahren immer populärer. Das liegt zum einen daran, dass Mikrocontroller und die zusätzliche Peripherie immer günstiger werden, aber auch an Schulen wird mehr in Richtung Mikrocontroller und Robotik unterrichtet.

Dieses speziell für Praktiker geschriebene Buch bietet zahlreiche detaillierte Bauanleitungen inklusive Quellcode und Schaltplänen für den Einsteiger sowie für den fortgeschrittenen Roboter-Entwickler. Die Beispielprogramme sowie Schaltpläne können für eigene Entwicklungen übernommen werden und dienen somit als Bausteine für eigene Ideen. Besonderen Wert wurde bei den Anleitungen auf Nachbausicherheit gelegt, und selbstverständlich wurden alle Projekte vom Autor selbst aufgebaut und ausführlich getestet. Durch die zahlreichen Beispiele ist es immer ein gutes Nachschlagewerk, das nicht so schnell im Bücherregal landen wird.

'''Aus dem Inhalt:'''
- Ausflug in die Roboterwelt
- Planen eines Roboters
- Mechanische Bauteile und Materialien
- AVR Controller und BASCOM Basic
- PC zu BOT Interface per Funk (Die Roboter Steuerzentrale)
- Sensoren und Aktoren
- Fahrregler im Selbstbau
- Kamerasysteme
- Diverse Algorithmen

'''Selbstbauprojekte:'''
GPS Navigationssystem, Tischroboter TR-1, Robo-Control mit ATmega32, Cybot-Pimp, Rasenmähroboter Grasshopper Phip, Induktionsschleifen-System, On Screen Display im Eigenbau, 12-V-Bleigellader, diverse I²C Erweiterungen für das Robo-Controlboard, Der große Experimenttierroboter THX-1

'''Auf CD-ROM:'''
* Kompletter Quellcode zum Buch
* Tools zur einfachen Roboterentwicklung
* Steuern vom PC aus mit dem PC to Bot Interface
* Datenblätter zu den verwendeten Bauteilen

----

'''Lesermeinungen:'''
Jeder, der sich intensiv mit Elektronik beschäftigt, kommt irgendwann auf den Roboter. Ein paar einfache Modelle habe ich auch schon gebaut, aber meist war die Mechanik eher kümmerlich. Ganz anders bei Ulli Sommer. Er zeigt mit diesem Buch, wie es richtig gemacht wird! Letzte Woche hatte ich Besuch von einem Freund, der sich aktuell intensiv mit Robotern beschäftigt. Es sah das Buch auf meinem Schreibtisch liegen, griff es sich und las es quer. Seine Reaktion sagt es besser, als ich es könnte: Da steht ja wirklich alles drin, was aktuell machbar ist, alle wichtigen Sensoren, Motoren, Treiber sind beschreiben, kein Thema fehlt, das man beachten sollte, wenn man Roboter baut! Was mich persönlich besonders interessiert hat, sind neue Motortreiber, die über den üblichen ULN2803 hinausgehen. Und da findet sich eine Menge. Sehr gut gefällt mir auch, dass durchgehend AVR-Controller mit BASCOM verwendet werden. Und für die PC-Seite der Steuerung wird VB.NET eingesetzt. Alles in Allem: Über 300 Seiten, prall gefüllt mit wertvollem Fachwissen, ein echtes Standardwerk zur Robotertechnik!

B.K.

----
'''Meinungen zum Buch:'''

This is a book in the German language. I received my copy today. When you can read German you are lucky! Why? Because this is a must have book! This book covers it all : Servo's, small motors, big motors, the AVR, small robots, advanced robots, even with GPS , and a real big Robot you can use for your own 'Star Wars movie'. There working/theory is explained, there are pictures and lots of cool projects. After you have read or browsed the book, you can only admit that i did not say too much about it! When it have finished the book completely I will give an update about the book. For those who can not read German, just hope that an English version will be released. Or ask the publisher.

Mark Alberts
MCS

Ein tolles Buch vor allem auch für Praktiker. Das Buch enthält zahlreiche Themen und Projekte die auch im Roboternetz immer wieder diskutiert werden. Beliebte Boards wie [[RN-Control]] und viele andere Robotikhardware.de-Komponenten werden erläutert und programmiert. Neben der Beschreibung zahlreicher Sensoren sind auch praktische [[Bascom]]-Beispielprogramme vorhanden. Wer sich im Roboternetz wohl fühlt wird auch dieses Buch mögen.

--[[Benutzer:Frank|Frank]] 13:41, 27. Mär 2008 (CET)

Erschienen Franzis-Verlag
Erscheinungsdatum: Feb 2008
ISBN 978-3-7723-4109-0
Bezug. z.B. Robotikhardware.de, Conrad-Electronic, Franzis, Amazon
49,95 Euro

<center>
http://www.roboternetz.de/wissen/images/3/38/Vg4109-0-3D.jpg
</center>

==Mikrocontroller-Bücher==
===Programmieren der AVR RISC Mikrocontroller mit BASCOM-AVR, Autor Claus Kühnel===
Das beliebte AVR Bascom-Buch von Claus Kühnel ist nun in einer völlig überarbeiteten und erweiterten Auflage erschienen. Ganze 376 Seiten umfasst dieses wirklich umfangreiche Werk.
Das Buch wurde nun auch um die neueren AVR –Typen AVR-Tiny und AVR-Mega erweitert. Also es wird nicht nur die Entwicklungsumgebung des Bascom Basic Compilers erläutert, sondern auch die Möglichkeiten der einzelen AVR-Controller. Dazu findet man zahlreiche Beispiele und ganz Applikationen im Buch. Angesprochen werden die Installation der IDE, der eingebauten Simulator, eingebaute Entwicklungstools wie LCD-Designer, Terminal-Emulator, Libary Manager als auch einige AVR-Starterkits. Bei den Starterkits ist das noch recht neue rn-Control leider noch nicht dabei, dennoch lassen sich die meisten Dinge auch auf rn-control übertragen und dort nachvollziehen.

Im Buch werden auch wichtige Schnittstellen wie SPI, USART, SPI (Hard- und Software), I2C-Bus (Hard- und Software), 1-Wire-Bus uvm. erläutert. Auch dazu findet man Programme, die einem beim Umsetzen in die Praxis helfen. Aber auch der Anschluss und die Programmierung externer Hardware, Motoren, DOT-Matrix-Anzeigen, LEDs, Matrix-Tastaturen und PC-AT-Tastaturen werden erläutert.

Ein wirklich sehr gelungenes Buch!

[[Bild:Buch_kuehnelbascom.png|center]]

Auch wenn einige Kapitel des Buches nicht unbedingt für Anfänger geeignet sind, so bleiben wegen des Umfangs immer noch genügend interessante Seiten übrig. Mein bisheriges Lieblingsbuch!
--[[Benutzer:Frank|Frank]] 18:18, 16. Nov 2005 (CET)

Autor: Claus Kühnel
376 Seiten
ISBN 3-907857-04-68
Preis EUR 34,95
Bezugsquelle. u.A. Amazon,robotikhardware.de

===AVR-Mikrocontroller Lehrbuch, Autor Roland Walter===

Warum schwer, wenn es auch einfach geht? - Das Buch führt leicht verständlich in die Welt der AVR-Mikrocontroller ein. Systematisch, Schritt für Schritt, mit der Hochsprache Basic und vielen gut kommentierten Beispiel-Listings. Was auch erwähnt werden muß: Der Stoff ist dicht und das Buch verzichtet auf "Seitenschinderei".
Als Programmiersprache wird der sehr effiziente Bascom-AVR-Basic-Compiler verwendet, der auch in einer kostenlosen Version erhältlich ist. Es wurde darauf geachtet, daß die Beispiel-Listings auch für C-Programmierer leicht verständlich sind. Darüber hinaus ist im Buch eine kurze Einführung zu C (AVR-GCC) von Wolfgang Neudert enthalten.
Als Grundlage dient der AVR-Typ ATmega8. Dieser preiswerte AVR ist durch seine umfangreiche Ausstattung gut geeignet, um als Beispiel für die gesamte AVR-Serie dienen zu können. Am Ende soll der Leser in der Lage sein, sich andere AVR-Typen selbst erschließen zu können.
Für die AVR-Experimente wurde ein einfaches und übersichtliches Experimentierboard entworfen und es werden verschiedene Fertig- und Selbstbau-Programmieradapter vorgestellt. Das Experimentierboard kann als Bauteilesatz mit Platine fertig gekauft oder selbst aufgebaut werden.
Das Buch hat 224 Seiten, drurchgängig Farbdruck. Zum Buch gehört eine CD-ROM mit der nötigen Software, den Beispielprogrammen und den Datenblättern.

Bestellung: Das Buch kann über die Webseite www.rowalt.de oder www.robotikhardware.de bestellt werden sowie über ausgewählte Elektronik-Händler. Bestellungen über den normalen Buchhandel sind bislang nicht möglich sein.

--[[Benutzer:Frank|Frank]] 18:20, 16. Nov 2005 (CET)

<center>
http://www.rowalt.de/mc/avr/avrbuch/coverb.png
</center>

----

===AVR-RISC Mikrocontroller, Autor Wolfgang Trampert===

Der Leser soll durch dieses Buch in die Lage versetzt werden, eigene Schaltungen mit diesen in fortschrittlicher RISC-Architektur entwickelten AVR-Controllern zu entwerfen, aufzubauen und zu testen.
Ein Programmiergerät für den Download selbst erstellter Programme in das Flash-EPROM des Controllers wird ebenso vorgestellt, wie eine Vielzahl von Anwendungsbeispielen für diese AVR Controllergeneration. Auf der dem Buch beiliegenden CD-ROM werden neben einem voll funktionsfähigen Assembler und einem Simulator für den Test eigener Programme alle Quell-Codes der vorgestellten Anwendungsbeispiele mitgeliefert und können vom Leser unmittelbar in eigene Projekte übernommen werden. Das Buch wendet sich an Entwickler, Ingenieure, Auszubildende, Studenten und Dozenten sowie an engagierte Hobbyelektroniker, kurz gesagt an alle, die diese neue Generation von Single-Chip-Controllern kennen und verstehen lernen wollen

Aus dem Inhalt: CPU; Zeitgeber, Zähler; Watchdog Timer; Asynchrone Datenübertragung über die Ein-/Ausgabe-Ports; Befehlsvorrat; Das AVR-Studio; AVR-Controller; AVR-Applikation; C-Datenblätter Angaben zum CD-Inhalt: Vollversion des AVR-Assemblers, Vollversion des AVR- Studios, Der Sourcecode aller Programme, Datenblätter aller AVR-Controller, AVR- Applikationen, C-Datenblätter

Das Buch eignet sich sehr gut auch als Nachschlagewerk und zur Vertiefung bestimmter Techniken. So wird beispielsweise der I2C-Bus in kaum einem anderen Buch so ausführlich, genau und verständlich erläutert wie in diesem Buch. Da sich ein Großteil der Seiten sehr ausfühlich das AVR Assembler Entwicklungssystem sowie die einzelnen Assemblerbefehlen befasst, dürfte das Buch für für Assembler-Einsteiger von besonderem Nutzen sein.

Ein Manko des Buches ist, dass die neue AVR MEGA-Controllerserie (z.B auch der Mega32 von rn-control) noch nicht konkret im Buch angesprochen wird. Konkret werden vorwiegend kleinere AVR Controller behandelt, welche heute eigentlich nur noch in geringer Zahl zum Einsatz kommen dürften, zumindest bei Hobby-Bastlern. Auch die oft eingesetzten Entwicklungssysteme GCC C-Compiler und Bascom-Basic werden leider noch nicht in dem Buch angesprochen. Dennoch ist das Buch wegen verschiedener Hardware-Grundlagen als Nachschlagewerk unbedingt empfehlenswert.

<center>
http://images-eu.amazon.com/images/P/3772354769.03.MZZZZZZZ.jpg
</center>

Gebundene Ausgabe 462 Seiten
Franzis Verlag
ISBN 3772354769
Bezug: Buchhandel / Amazon.de

----

===BASCOM-AVR – Sprachbefehle, Autor Mario Meissner===
Dieses Buch stammt vom Autor Mario Meissner, welcher bereits ein anderes Bascom-Buch geschrieben hat. In diesem Werk beschäftigt er sich ausschließlich mit der Beschreibung aller Bascom-Basic-Befehle. Damit ergänzt das Buch hervorragend alle bisher erschienen Bascom-Bücher, die vorwiegend ausgewählte Möglichkeiten der Controller und bestimmte Aspekte der Programmiersprache behandeln.
Dass auch eine umfassende Befehlsbeschreibung noch notwendig war, zeigt schon der enorme Umfang des Buches. Es ist ein Wälzer von über 530 Seiten entstanden!!! Allein das zeigt, welche Möglichkeiten in dieser zum Teil noch unterschätzen Programmiersprache stecken.

<center>
http://www.shop.robotikhardware.de/shop/catalog/images/imagecache/meisbuch3.jpeg
</center>

Das neue Buch umfasst im wesentlichen den kompletten Inhalt der hervorragenden englischsprachigen Dokumentation, welche sonst nur als Help-File mitgeliefert wird. Das Ganze ist auch ähnlich übersichtlich gegliedert:

* Befehl
* Parameter
* Erläuterung
* Verzweigungen zu ähnlichen Befehlen
* Democode

Auch wenn große Teile des Buches sehr ähnlich dem englischen Help-File sind, so bietet das Buch selbst für Leser mit guten englisch Kenntnissen eine echte Hilfe. Denn wer liest schon eine Help-Datei so gigantischen Ausmaßes wirklich seitenweise durch? Dies führt dazu, dass man über die Existenz vieler Befehle einfach gar nicht informiert ist.
Ein gedrucktes Buch dagegen ermuntert doch immer ein wenig zum Blättern. Ich bin sicher, dass der Leser noch zahlreiche Befehle findet, die er schon längst hätte brauchen können, aber von deren Existenz er einfach nichts wusste. Auch mir ist es so gegangen, obwohl ich schon einige Bücher zu Bascom gelesen habe und auch recht oft die Help-Datei zu Rate ziehe.
Besonders angenehm ist, dass auch die Kommentarzeilen innerhalb der zahlreichen Beispiele nicht in englisch sondern in deutsch gehalten sind. Zudem sind auch neuste Bascom Zusatz-Libarys bereits in dem Buch aufgeführt.

Alles in allem ist ein wirklich gutes Referenzwerk zum Nachschlagen entstanden. Es eignet sich keinesfalls nur für Einsteiger sondern ohne Zweifel auch für erfahrene Programmierer. Ideal also auch für Roboter-Bastler, die sich für AVR-Boards, wie zum Beispiel Eigenentwicklungen, [[RN-Control]], RNBFRA-Board und andere entschieden haben.

Autor: Marius Meissner
Auflage , 8/2004
Deutsch , ca. 538 Seiten
broschiert , inkl. 1 CD
ISBN: nicht vorhanden
Preis: 41,73 Euro inkl. Mwst.
Bestellung nur über:
Autor Mario Meissner http://bascom-avr.de/Buch.aspx?ID=2
oder http://robotikhardware.de

----

===Softwareentwicklung in C für Mikroprozessoren und Mikrocontroller, Autor Jörg Wiegelmann===

Dieses Buch bietet eine allgemeine, praxisorientierte Einführung sowie einen Praxisteil. Der allgemeine Teil ist möglichst werkzeug- und prozessorunabhängig aufgebaut. Er enthält und beschreibt mit zahlreichen praxisbezogenen Tipps alle notwendigen Grundlagen, Werkzeuge und Informationen wie Einführung in C, Compiler, Linker, Library, Make, C-Programmierung für Embedded-Systeme, Quellcode, Tools und Entwicklungsumgebung, Systemdesign und objektorientierte Programmierung. Neben neuen Abschnitten zu Softwarekomplexität und Dokumentation sind zahlreiche Detailverbesserungen und Erweiterungen eingeflossen.

Im Praxisteil wird das theoretisch dargestellte Wissen in einer kompletten, aktualisierten Fallstudie veranschaulicht und vertieft. Die Werkzeuge und der Prozessor der Fallstudie sind so ausgewählt, dass eine Umsetzung mit möglichst geringem Aufwand erfolgen kann.

Wer eigene Projekte in C für Embedded-Systeme entwickeln möchte, findet somit in diesem Buch alles Notwendige.

Die beiliegende CD-ROM enthält eine Vielzahl von aktuellen, nützlichen Programmen für die Praxis in der Softwareentwicklung wie Gnu-C-Compiler, Software und Beschreibung zum Selbstbau eines Low-Cost-Programmiergerätes, Software zur Verwaltung, Komplexitätsanalyse und Dokumentation von Quellcode, eine Softwareentwicklungsumgebung und die im Buch behandelte Fallstudie als kompletten Quellcode. Alle beigefügten Programme sind Vollversionen und in ihrem Einsatz nicht beschränkt.

Broschiert - 309 Seiten - Hüthig
Erscheinungsdatum: September 2004
ISBN: 3778529439
39,80 Euro
Bezug: z.B. Amazon.de

<center>
http://images-eu.amazon.com/images/P/3778529439.03.MZZZZZZZ.jpg
</center>

----

===Messen,Steuern und Regeln mit ARM-Microcontrollern, Autor Klaus-Dieter Walter===
'''Klappentext:''' Messen, Steuern und Regeln mit ARM-Mikrocontrollern Mikrocontroller sind in der Elektronik heute allgegenwärtig. Meist unbemerkt versehen diese programmierbaren, integrierten Bausteine ihren Dienst. Ob in einer Waschmaschine, einem Handy oder in der ABS-Bremsanlage eines Autos -immer sind Mikrocontroller am Werk. ARM ist die Bezeichnung für eine 32-bit-Mikrocontroller-Architektur. Namensgebend ist die englische Firma ARM Limited. Diese Firma produziert selbst keine Mikrocontroller, vertreibt aber Lizenzen an Lizenznehmer, die ARM-basierte Mikrocontroller entwickeln, fertigen und vermarkten. ARM Mikrocontroller bieten beachtliche Leistungsmerkmale zu einen günstigen Preis, weshalb sich diese Leistungsklasse sehr rasant verbreitet hat. ARM-Mikrocontroller bilden das Herz vieler eingebetteter Systeme (Embedded Systems). Dieses Buch bietet eine Einführung in die wichtigsten Merkmale und Besonderheiten der ARM-Architektur. Anhand verschiedener ARM Mikrocontroller- und ARM-Modul-Beispiele werden die umfangreichen Peripheriefunktionen und deren Einsatz für MSR-Aufgabenstellungen erläutert. Im Zusammenhang mit dezentralen MSR-Anwendungen sind ARM Mikrocontroller besonders für Vernetzungsaufgaben geeignet. Aus diesem Grund bietet das Buch eine Einführung in Ethernet-basierte TCP/IP-Netzwerke und die ARM-Integration in solche Netze. Dabei kommen auch Embedded-Betriebssysteme wie z. B. Linux zur Sprache

<center>
http://images-eu.amazon.com/images/P/3772340172.03.MZZZZZZZ.jpg
</center>

'''Persönliche Lesermeinung:''' Ein sehr hilfreiches und gelungenes Buch wenn schon etwas Microcontroller-Erfahrung besitzt und zum Beispiel von reinen Risc- Microcontrollern auf einen [[Microcontroller]] der ARM-Architektur umsteigt. Schon nach dem Anlesen merkt man das der Autor wirklich was von der Materie versteht und sich dort richtig Zuhause fühlt. Perfekt wird unter anderem der Unterschied und der Zusammenhang der Architekturen und Microcontollerarten ([[Arm|ARM]], RISC, CISC, MSR) erläutert. Übersichtliche und endlich mal verständliche Diagramme helfen hier sehr. Natürlich wird auch Erläutert welche Entwicklungssystem, Betriebssysteme (z.B. wird auf Linux eingegangen) der ARM Baureihe verwendet werden können. Ein weiterer Schwerpunkt sind die verschiedenen MSR Schnittstellen wie [[UART]], SPI, [[I2C]], CAN, USB Ethernet und weitere.
Fazit: Obwohl das Buch nicht ganz neu ist, scheint es mir eine gutes Einführungswerk für diese doch recht schwere Materie zu sein, insbesondere wenn man auch schon mit kleineren 8 Bit Microcontrollern ([[Avr]]/Pic) gearbeitet hat.

--[[Benutzer:Frank|Frank]] 21:02, 7. Dez 2005 (CET)

Gebundene Ausgabe mit 379 Seiten
Erschienen im Franzis -Verlag September 2004
ISBN: 3772340172
Preis 39,95 Euro
Bezug: Buchhandel, Amazon etc.
----

===Das große PIC-Mikro Handbuch, Autor Anne und Manfred König===
'''Klappentext:'''Die Autoren haben viele Jahre Erfahrung mit industriellen PIC-Mikro-Projekten. Sie behandeln das Thema aus der Sicht ihres Entwickler-Alltags. Dazu gehört auch die ganze Peripherie, also alles was um die PIC-Mikrocontroller herum von Bedeutung ist. Dazu zählen z.B. analoge Peripheriebausteine und die Entwicklungsumgebung, bestehend aus MPLAB inklusiv der Debugger und den Demoboards.
Dieses Buch richtet sich an Interessenten, die bereits erste Erfahrungen mit PIC-Mikrocontrollern gesammelt haben. Der Schwerpunkt liegt auf den neuen Entwicklungen der letzten Jahre. Dazu gehört natürlich in erster Linie die PIC18 Generation, die mit dem 16 Bit-Kern nicht nur höheren Programmierkomfort beinhaltet, sondern vor allem eine Fülle neuer technischer Möglichkeiten
bietet. Aber auch von den PICs mit 14 bzw. 12 Bit-Kern gibt es viel Neues zu berichten.

Aus dem Inhalt:
*Serielle Kommunikation
*PIC18
*Powermanagment
*Die neuen PIC10F und rfPIC
*PIC in Assembler programmieren
*Entwicklungssystem MPLAB 6.XX
*Der In-circuit-Debugger und Programmer ICD2
*Demoboards und Peripheriebausteine

<center>
http://images-eu.amazon.com/images/P/3772359957.03.MZZZZZZZ.jpg
</center>

'''Persönliche Lesermeinung:'''Ich habe mir das Buch besorgt um auch mal einen Einblick in die PIC-Welt zu bekommen. Beurteilen kann ich das Buch nur als PIC-Einsteiger, da ich eigentlich vorwiegend mit [[AVR]]-Controllern arbeite. Das Buch ist gut strukturiert und geht sehr gut auf die einzelnen Features, Eigenschaften und Architekturen der PIC-Controller ein. Dabei wird auch schon die derzeit neue PIC18 Serie berücksichtigt. Register werden oft in Verbindung mit kleinen Assembler-Beispielen und anschaulichen Tabellen erläutert. Schade ist nur, das wohl keine Basic Entwicklungsumgebung auf der CD vorhanden ist. Dem Assemblerfreund dürfte jedoch das enthaltene MLAB Entwicklungssystem alles notwendige mitbringen. Etwas schade ist, das auf die Pic-Typen mit USB Schnittstelle nur relativ kurz eingegangen wird.

--[[Benutzer:Frank|Frank]] 16:05, 9. Dez 2005 (CET)

Gebundene Ausgabe mit 312 Seiten
Erschienen im Franzis-Verlag Februar 2005
Auflage: 1
ISBN: 3772359957
Preis: 39,95 Euro
Bezug: Buchhandel, Amazon etc.

== Elektronikbücher ==
=== Elektronik-Fibel, Patrik Schnabel ===
'''Lesermeinung von [[Benutzer:LUMA|Luma]]:''' Das Buch gibt einen Überblick über elektronische Grundlagen, Bauteile, Schaltungstechnik, Messtechnik und Digitaltechnik. Der Leser meint also, ein kompaktes Buch über Elektronik und alles was dazugehört in der Hand zu halten. Leider sind viele Kapitel viel zu oberflächlich und das Layout wurde wohl mit dem miserablen Programm, dem Layout leider fremd ist, einer bekannten Softwareschmiede geschaffen. Anders kann man sich das, an vielen Stellen, katastrophale Layout nicht erklären. Ein weiterer Kritikpunkt sind die miserablen Grafiken. Ansonsten ist das Buch ganz gut geeignet zum Nachschlagen geeignet. Ich empfehle das Buch allen, die sich in Elektronik noch nicht so gut auskennen und ein kompaktes Buch zum Nachschlagen suchen (also nicht nur Elektronikbastlern sondern auch Schülern). Als Alternative bietet sich die Website des Autors (siehe unten) an. Dort gibt es das ELKO in dem man sehr viele Informationen zum Thema finden kann.

[[Benutzer:LUMA|Luma]]

Autor: Patrick Schnabel Webseite: http://www.elektronik-fibel.de
245 Seiten, broschiert
ISBN 3-83114-59-03
Preis EUR 15,50
Bezugsquellen: Amazon, ...

<center>
http://www.elektronik-fibel.de/uploads/elektronik-fibel/cover.gif
</center>

==Programmiersprachen==

===C Programmieren von Anfang an, Autor Helmut Erlenkötter===
Dieses Buch von Helmut Erlenkötter finde ich, ist sehr zu empfehlen.
Es bietet einen guten Einstieg in die Programmierung mit C für Ein- und Umsteiger.
Es ist meiner Meinung nach gut für 'blutige' Anfänger geeignet, denn es erklärt sehr genau, was passiert, und wo man aufpassen muss.

Nach jedem Kapitel werden Aufgaben gestellt, um das erworbene Wissen zu testen.

Es gibt viele Codebeispiele, bzw. die ganze Programmierung wird anhand von Codebeispielen erklärt.
Jeder Schritt in einem Listing wird gesondert erklärt, was die Übersicht des Buches und der Listings enorm erhöht.

'''Die Kapitel:'''

# Prolog
# Erste Schritte
# Mit Zahlen arbeiten
# Entscheidungen treffen
# Wiederhohlen von Programmteilen
# Funktionen definieren
# Felder und Zeichenketten
# Variablen und Konstanten
# Der Präprozessor
# Pointer
# Kommandozeilenparameter
# Dateien benutzen
# Fehler kontrollieren
# Komplexe Dateitypen
# Programmiertechniken
# C und Objekte
# Anhang

Eine komplette ASCII-Tabelle befindet sich im Anhang.

Das Buch verfügt über einen großen und ausführlichen Glossar.

Sterne: * * * * *

'-by tobimc-'

by Helmut Erlenkötter
RORORO, ISBN 3-499-60074-9
Broschiert, 9,90€ (D)

<center>
[[Bild:Buch-C.jpg]]
</center>

----

===C++, Objektorientiertes Programmieren von Anfang an, Autor Helmut Erlenkötter===

Auch dieses Buch bietet sich für Ein- und Umsteiger an, da auch hier wieder von Anfang an auf die Eigenarten dieser Programmiersprache eingegangen wird. Zu Beginn werden die Unterschiede zwischen C und C++ aufgeführt und dann geht es auch schon sofort los. Wie in all seinen Büchern, geht der Autor sehr schön systematisch vor. Es werden immer wieder Beispiele genannt, die den behandelten Stoff aufnehmen. Er weist auf eventuelle Fehler hin, die gemacht werden können und spricht jede Änderung oder Neuerung sofort durch. Am Ende eines jeden Kapitels gibt es Aufgaben zu lösen. Alle Lösungen für diese Aufgaben finden sich am Ende des Buches. Und auch hier hat der Autor wieder eine Menge an zusätzlichen Daten in das Glossar gepackt und eine ASCII-Tabelle fehlt auch hier nicht.

Als weiterführendes Buch, nach "C programmieren von Anfang an" auf jedenfall zu empfehlen.

von Helmut Erlenkötter
ISBN 3-499-60077-3
Broschiert, 10,50 € (D)

<center>
[[Bild:Buch-c--.jpg]]
</center>

==Metallbearbeitung==
===Fachkunde Metall===

Das nahezu 600 Seiten starke Buch macht gleich beim Aufschlagen einen guten Eindruck. Keine langen Vorworte und Danksagungen, sondern auf Seite 3 eine grobe Übersicht der relevanten Themen.

#Längenprüftechnik
#Fertigungstechnik
#Werkstofftechnik
#Maschinen und Gerätetechnik
#Automatisierungstechnik
#Informationstechnik
#Elektrotechnik

Der groben Übersicht folgt ein detailliertes Inhaltsverzeichnis. Am Ende des Buches befindet sich ein Stichwortverzeichnis.

[[Bild:fachkundemetall.jpg|center]]

1) Längenprüftechnik:

Über Größen und Einheiten gelangt der Leser zu den Grundlagen der Messtechnik. Besonders gut gefiel mir hier die reich bebilderte Darstellung der möglichen Messfehler. Dies kommt gerade dem Anfänger zu Gute.
Vorgestellt werden neben den gängigen Messmitteln wie Stahlmaßstab, Messschieber (landläufig als Schieblehre bekannt), Bügelmessschraube (Mikrometer) und Messuhr (zum Ausrichten auf Dreh- und Fräsmaschinen) auch weiterführende Messmittel bis hin zu pneumatischen, induktiven und optischen Messverfahren.
Für ambitionierte Roboterbauer folgen noch weitere Kapitel in den Bereichen Oberflächenprüfung
Toleranzen und Passungen, Form und Lageprüfung

2) Fertigungstechnik:

Hier sind besonders die Kapitel a) Umformen und b) spanende Fertigung erwähnenswert.
Umformen (Verhalten der Werkstoffe und Biegeumformen) zu erwähnen.
Jeder, der schon mal ein Werkstück gebogen hat und nach dem Biegevorgang feststellte, dass die Maße nicht stimmten findet hier Abhilfe.
Der größte Block in diesem Abschnitt ist zweifellos die spanende Fertigung.
Darunter versteht man ganz profan alle Fertigungsverfahren, bei denen Späne anfallen.
Ausgehend von den Grundlagen der spanenden Fertigung, der Werkzeugschneide, Schneidstoffe und Kühlschmierstoffe werden die für den Hobby-Roboterbauer unumgänglichen Themen: Sägen, Bohren, Senken behandelt.
Hier hätte ich mir noch einen weiteren Block, der das Thema „Feilen“ behandelt, gewünscht. Gerade der Hobby-Roboterbauer ist in der Formgebung oft auf dieses Verfahren angewiesen.
Für den ambitionierten Roboterbauer werden selbstverständlich auch die Themen:
Reiben, Drehen, Fräsen, Schleifen sowie Vorrichtungen und Spannelemente reich bebildert abgehandelt.
Ein weiterer großer Block den kein Roboterbauer umgehen kann ist der des Fügens. Wie kommen meine Teile zueinander und welche Verfahren wende ich an? Schrauben, Pressen, Schnappen, Kleben, Löten, Schweißen? Diese Fragen werden dort geklärt.

3) Werkstofftechnik:

Wie ein roter Faden zieht sich auch in diesem Kapitel die saubere Gliederung durch das umfassende Thema. Angefangen von der Übersicht der Werk- und Hilfsstoffe über die Auswahl und Eigenschaften der Werkstoffe zum inneren Aufbau der Metalle.
Besonders interessant ist auch für den Hobby-Roboterbauer die Frage, mit welchem Werkstoff arbeite ich?
Diese Frage wird entsprechend den Klassifizierungen der Werkstoffe behandelt. Einen Stahl mit der Kennung „45 Cr Mo V 6-7“ kann man nach dem Studium der Kapitel zuordnen.
Leider ist das Kapitel der Nichteisenmetalle etwas kurz gehalten. Aluminium (als Leichtmetall) ist unter den Roboterbauern ein sehr beliebter Stoff. So wird zwar erwähnt, dass man Aluminium, ähnlich wie Stahl, härten kann, eine Beschreibung des Verfahrens fehlt aber.
Der Leser bekommt aber einen Überblick über die Nichteisenmetalle. Nach dem Studium der entsprechenden Seiten kommt beispielsweise kein Roboterbauer auf den Gedanken eine Gleitlagerung aus Aluminium-Aluminium zu bauen.
Die Themen: Sinterwerkstoffe, Keramische Werkstoffe, Wärmebehandlung der Stähle (ggf. auch für den Roboterbauer interessant), Werkstoffprüfung (Zugfestigkeit, Härte, Metallurgie usw.) werden ebenfalls besprochen.

Des weiteren findet sich ein eigenes Kapitel zur Korrosion und Korrosionsschutz in diesem Abschnitt.
Auf sechs Seiten wird beschrieben, wie es zur Korrosion kommt (incl. elektrochemischer Spannungsreihe). Korrosionsschutzmaßnahmen bis hin zu Fremdstromanoden (sog. Opferanoden) werden angesprochen.

Mit dem Themenkomplex der Kunststoffe geht es weiter. Ausgehend von „Eigenschaften und Verwendung“ über die Aufklärung bezüglich Thermoplaste, Duroplaste und Elastomere bis hin zur Formgebung findet man einiges an Informationen. Insbesondere im Bereich der Weiterverarbeitung findet der Leser einige, auf die Industrie zugeschnittene Verfahren. Manches lässt sich aber, mit Kreativität, auch zu Hause durchführen.

Das Kapitel schließt mit den beiden Themen
Verbundwerkstoffe und, auch für uns wichtig, der Umweltproblematik der Werkstoffe.

4) Maschinen und Gerätetechnik:

Über die Einteilung der Maschinen (z.B: Kraftmaschinen, Arbeitsmaschinen usw.) und den Funktionseinheiten der Maschinen (welche exemplarisch an Beispielen wie CNC Werkzeugmaschine, Kraftfahrzeug, Klimaanlage besprochen werden), bis hin zu Sicherungseinrichtungen, sowie Bedienung und Instandhaltung gelangt man zu den für uns ebenfalls wichtigen Themen der:
Beanspruchung und Festigkeit. Die einzelnen Beanspruchungsfälle werden anhand von: Schraubverbindungen, Stiftverbindungen, Nietverbindungen und Welle-Nabe-Verbindungen besprochen.
Weiterhin werden auch Reibung und Schmierstoffe, Gleit und Wälzlager, Führungen, Dichtungen und Federn abgehandelt.
Nach durcharbeiten des Themenkomplexes kennt der Roboterbauer Begriffe wie statische Belastung und die drei Formen der dynamischen Belastung.
Zug-, Druck-, Abscher-, Biege-, Verdreh- (Torsions-), oder auch zusammengesetzte Beanspruchung werden exemplarisch und bebildert erläutert.

Weitere Themen sind die Schraubverbindung (Gewindearten, Einteilung, Verwendung), Schraubensicherung (sehr wichtig bei dynamischen Belastungen im Roboterbau), Stiftverbindungen (Zylinderstifte, Kegelstifte, Kerbstifte)
Nietverbindungen, Welle-Nabe-Verbindungen (formschlüssige, sowie kraftschlüssige)
Der große Komplex der Gleit- und Wälzlager, Führungen, Dichtungen und Federn wird hier sehr gut in Wort und Bild dargestellt.

Auf all diese Themen im einzelnen einzugehen würde den Rahmen dieser Besprechung bei weitem sprengen. Es ist für jeden Roboterbauer (auch ohne Drehmaschine mit Fräseinrichtung) ein lesenswertes Thema. Für die, welche eine kleine Drehmaschine und/oder Fräse ihr Eigen nennen geradezu ein Muss!
Weitere Themen in diesem Kapitel sind: Funktionseinheiten zur Energieübertragung (Wellen, Achsen, Kupplungen, Riementriebe, Kettentriebe, Zahnriementriebe, sowie Elektromotoren, für den Industriebedarf und Getriebe – Linearantriebe)
Die verbleibenden Abschnitte in diesem Kapitel (Montagetechnik und Fertigungseinrichtungen) orientieren sich weitestgehend an industrielle Bedürfnissen.

Zwischenfazit zu diesem Kapitel:
Ein, mit 108 Seiten sehr gut und kompakt abgehandelter Themenkomplex, der insbesondere für den Roboterbau sehr viele grundlegende Informationen im Bereich Mechanik vermittelt. Auch der Leser, welcher nicht über eine komplett ausgerüstete Metall-Werkstatt verfügt findet hier Anregungen, die oft mit einfachen Mitteln zu besseren Ergebnissen führen kann.

Auch der Laie wird nach dem Studium dieses Kapitel wissen, ob er ein metrisches Normalgewinde oder Feingewinde oder sogar ein Trapezgewinde einsetzen muss. Nehme ich ein Gleitlager oder Wälzlager. Benutze ich eine einfache Flachführung, Führung mit Kugelumlaufspindel oder ein Wälzführung mit Laufrollen. Möglichkeiten zum spannen von Riemen, Aufbau von Ketten Zahnrädern und Getrieben werden ebenfalls dargestellt.
Die Themen sind reich bebildert und mit zumindest einführenden Texten behandelt. Berechnungsbeispiele findet der Leser exemplarisch, aber nicht durchgängig. Dies macht auch Sinn, da ansonsten das Buch mit seinen nahezu 600 Seiten gesprengt würde. Die Berechnungen findet man in einem eigenen Mathe-Buch in Kombination mit dem Tabellenbuch. Beide werde ich zu einem späteren Zeitpunkt besprechen.

5) Automatisierungstechnik

Gerade der Roboter-Bauer ist besonders an der Automatisierungstechnik interessiert. Dieser Komplex wird in dem vorliegenden Buch auf ca. 80 Seiten behandelt.
Anhand von bebilderten Beispielen wird vieles in den Grundlagen gut dargestellt. Des weiteren bietet dieses Thema einen Einblick in die Pneumatik und Hydraulik. Logische Verknüpfungen, SPS und CNC – Steuerungen werden angeschnitten. Für einen Einstieg in die Thematik ist dieses Buch, auch aufgrund seiner Begriffsdefinitionen gut geeignet. Mikrocontroller-Programmierung, oder gar beispielhafte Lösungen im Bereich der Mikrocontroller findet man in einem Fachbuch der Metallkunde natürlich nicht
Das Thema der CNC-Maschinen incl. der Programmierung ist dann ausführlicher behandelt (26 Seiten). Wer also plant, sich eine kleine CNC- Fräse zuzulegen oder um(selbst)- zu bauen, findet in diesem Kapitel einiges an Informationen rund um die CNC-Maschine.

6) Informationstechnik

Das Kapitel Informationstechnik wird in die Bereiche Technische Kommunikation und Grundlagen der Computertechnik eingeteilt.
Hier findet man nur einen kleinen Abriss der ansonsten sehr umfangreichen Themen. Das Thema Technische Kommunikation ist zwar wichtig, aber dafür gibt es spezielle Bücher.
Zum Thema Computertechnik stelle ich die These auf, dass die Mehrzahl der Forum-User mehr darüber wissen, als in dem Buch beschrieben ist.

7) Elektrotechnik

Das Buch endet mit dem Thema Elektrotechnik.
Die Themen Spannung, Strom, Wiederstand (und deren Schaltungen), sowie Stromarten, Leistung und Arbeit, Überstrom-Schutzeinrichtungen und Fehler an elektrischen Anlagen und Schutzmaßnahmen, werden gerade für den Laien sehr gut und einführend beschrieben.

Die mitgelieferte CD ist überschrieben mit: „Bilder und Tabellen – interaktiv“.
Und damit ist die CD auch schon nahezu beschrieben.
Erwähnenswert wäre noch die Möglichkeit einzelne Ergänzungen in Form von bebilderten Abfragen (Schema: richtiger Begriff) vorzunehmen. Dies ermöglicht ein gewisses Training im Umgang mit den Fachtermini.

Die großen Möglichkeiten eines interaktiven Mediums zum Buch wurden hier zwar im Ansatz realisiert, aber bei weitem nicht voll genutzt. Möglich wäre z.B: ein Lexikon der Fachbegriffe, welche bei entsprechender Eingabe auf den Artikel in den Büchern (Fachkunde, Fachrechnen, Tabellenbuch) verweist, sowie eine kurze Darstellung auf dem Monitor (ggf. mit Grafik/Foto). Des weiteren könnte man eine online-Schnittstelle zu Wikipedia einrichten.
Der Ansatz der CD ist sicherlich gut, aber das Potenzial der Medien (CD-Rechner-Intenet) ist bei weitem nicht ausgereizt.

Fazit:

Obwohl das Buch in erster Linie auf die Arbeit in der industriellen Fertigung zugeschnitten ist, bringt es auch dem ambitionierten Hobby-Bastler einen reichen Zugewinn.
Ein wirklich lohnenswertes Buch für alle, die mit Metallen (und anderen Werkstoffen) oder Maschinen arbeiten und sich nicht scheuen, Zeit in die Durcharbeitung der für sie relevanten Themen zu investieren.
Die reiche Bebilderung (ein Bild sagt mehr als tausend Worte!), sowie die prägnante Beschreibung machen ein lernen mit diesem Buch sehr effektiv. Auch den Preis halte ich für mehr als gerechtfertigt.

[[Benutzer:Klingon77|Klingon77]] 20. Feb 2007 (CET)

Fachkunde Metall
Europa Verlag
Auflage: 54
Europa Verlags NR: 10129
ISBN 3-8085-1154-0

----

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Robotikeinstieg]]
[[Kategorie:Elektronik]]

Wunschthemen

2008-03-30T17:07:31Z

RobotProgger: /* Meine Wunschthemen */

Auf dieser Seite kann '''jeder''' Themen nennen, die er sich in diesem Wiki wünschen würde. Die Seite dient Usern, die gerne was schreiben möchten, als Anregung. Hat jemand ein entsprechendes Thema erstellt, kann er es auch aus dieser Liste wieder streichen.

==Meine Wunschthemen==

'''Allgemeines'''
* Spracherkennung
* [[Schaltung AVR-Digitizer]] um Videobild mit AVR zu digitalisieren und auszuwerten oder per Funk zu übertragen
* Ausführliche Bedienhinweise für Euroflex-Saugroboter Monster Intelligente F1
* Künstliche Neuronale Netze
* Roboter-Filme
* [[Formula Flowcode Buggy]]
* Wie ist eine Grundschaltung für einen Roboter aufgebaut, dh. wie werden Motoren mit AVR's angesteuert, wie Sensoren ausgelesen? etc.

'''Programmierung'''
* Enwickeln eines universellen Programms, das ein Programmablaufdiagram (PDA) direkt in ausführbaren Code für ein bestimmter Prozessor (Maschinensprache) wandelt
* [[Network_Controller/PC_Praxis#Network_Controller.2FPC_RS232_mit_Windows|Ansprechen der RS232 Schnittstelle mit gängigen Programmiersprachen]]
* Pda und PPC steuerung über CF und MMC slot
* [[GCC]] Einführung mit Beispielen (welche Beispiele? Benutzung von GCC? (Optionen, ...)?, Programmbeispiele (also [[C-Tutorial]])?), für spezielle Maschinen oder Derivate? ANSI-C? Was fehlt in den [[:Kategorie:Quellcode C|C-Beispielen]]?)
* Mehr C Tutorials wie bei Bascom für LCDs,....
* C-Control 2 Tutorial
* PIC16F... Programmierung mit dem Go Embedded Pascal-Compiler
* PIC18F... Einführung

'''Hardware'''
* CNY70
* CNY70 als Liniensensor (analoge / digitale Auswertung)
* Serielles AVR-ISP Programmierkabel
* USB-ISP Programmieradaper
* Schnittstellen Übersicht (Es sollten alle gängigen Schnittstellen mit Vorteilen, Nachteilen etc. aufgelistet werden, damit man für jede zu bewältigende Aufgabe die am besten geeignete Schnittstelle wählen kann)
* JTAG mit AVRs
* Shift-/Schieberegister
* Sensorschaltung Windrichtung
* Sensorschaltung Luftfeuchte
* Schaltungssicherheitsvorkehrungen (wenns nicht nur auf dem Basteltisch funktionieren soll)
** ESD-Sicherheit
*** ESD-konformes Routing
*** ESD-Bauteile (Supressor Dioden, etc.)
*** Abschirmung bei Leitungen, Gehäuseauswahl, etc.
** Kurzschlusssicherheit
** Verpolungsschutz
** Überspannungsschutz
* Kondensator mit Beispielschaltungen
* Bluetooth Support (senden/empfangen) nach dem Vorbild des Lego NXT
* Microcontroller Entwicklungsboards
* Quarz-Bausteine: Funktionsprinzip und Beispielschaltungen (fehlt bisher komplett)

==Folgende erscheinen noch unvollständig und sollten von Usern die in dem Bereich kundig sind, ergänzt werden==
Findet man jetzt durch folgenden Link: [[:Kategorie:Artikelausbau]]
Artikel die unvollständig sind sollte man jetzt also nicht mehr hier aufgelistet werden, sondern die Artikel sollten am unteren Ende durch folgendes Kommando ergänzen werden:

<pre><nowiki>
{{Ausbauwunsch|Mehr Grundlagen und vor allem Programmbeispiele etc.}}
</nowiki></pre>

Im Artikel wird dann ein Hinweis eingeblendet, ähnlich wie diesem:

[[Bild:artikelausbau.gif]]

Also hier klicken um ausbaufähige Artikel zu finden:
* [[:Kategorie:Artikelausbau]]

----

Hier noch ein paar Artikel wo der Hinweis noch nicht drin steht:

* [[GNU Assembler|AVR Assembler (GNU) Einführung]]:
* [[Zahnrad]]
* [[Flipflop]]
* [[C-Tutorial]]
* [[Navigation]]
* [[Transistor]] (noch ein paar Bilder und vielleicht Grundschaltungen mit Beschreibung wären toll
* [[Avr-gcc|Dokumentation zu avr-gcc]]
* [[Arm]] Microcontroller
* [[GPS]] - Aufbau und Anwendung
* [[SPI]] - Vielleicht noch Beispiele
* [[Portexpander am AVR]] könnte nen BASCOM-Teil vertragen
* [[Manchester- Codierung]] - noch ein Programmbeispiel wäre toll
* [[JTAG]]

== Bereits erfüllte Wünsche ==
* stellenanzeigen-forum ->Gibt es bereits hier http://www.roboternetz.de/phpBB2/viewforum.php?f=29
* Filter (Hardware/Software) -> Wurde hier angelegt [[Filter (Elektronik)]]
* [[Roboterwettbewerbe]]
* Motortreiber (Einsteigerguide) -> [[Getriebemotoren Ansteuerung]]

[[Kategorie:RN-Wissen]]

Wunschthemen

2008-03-30T17:07:10Z

RobotProgger: /* Meine Wunschthemen */

Auf dieser Seite kann '''jeder''' Themen nennen, die er sich in diesem Wiki wünschen würde. Die Seite dient Usern, die gerne was schreiben möchten, als Anregung. Hat jemand ein entsprechendes Thema erstellt, kann er es auch aus dieser Liste wieder streichen.

==Meine Wunschthemen==

'''Allgemeines'''
* Spracherkennung
* [[Schaltung AVR-Digitizer]] um Videobild mit AVR zu digitalisieren und auszuwerten oder per Funk zu übertragen
* Ausführliche Bedienhinweise für Euroflex-Saugroboter Monster Intelligente F1
* Künstliche Neuronale Netze
* Roboter-Filme
* [[Formula Flowcode Buggy]]
* Wie ist eine Grundschaltung für einen Roboter aufgebaut, dh. wie werden Motoren mit AVR's angesteuert, wie Sensoren ausgelesen?

'''Programmierung'''
* Enwickeln eines universellen Programms, das ein Programmablaufdiagram (PDA) direkt in ausführbaren Code für ein bestimmter Prozessor (Maschinensprache) wandelt
* [[Network_Controller/PC_Praxis#Network_Controller.2FPC_RS232_mit_Windows|Ansprechen der RS232 Schnittstelle mit gängigen Programmiersprachen]]
* Pda und PPC steuerung über CF und MMC slot
* [[GCC]] Einführung mit Beispielen (welche Beispiele? Benutzung von GCC? (Optionen, ...)?, Programmbeispiele (also [[C-Tutorial]])?), für spezielle Maschinen oder Derivate? ANSI-C? Was fehlt in den [[:Kategorie:Quellcode C|C-Beispielen]]?)
* Mehr C Tutorials wie bei Bascom für LCDs,....
* C-Control 2 Tutorial
* PIC16F... Programmierung mit dem Go Embedded Pascal-Compiler
* PIC18F... Einführung

'''Hardware'''
* CNY70
* CNY70 als Liniensensor (analoge / digitale Auswertung)
* Serielles AVR-ISP Programmierkabel
* USB-ISP Programmieradaper
* Schnittstellen Übersicht (Es sollten alle gängigen Schnittstellen mit Vorteilen, Nachteilen etc. aufgelistet werden, damit man für jede zu bewältigende Aufgabe die am besten geeignete Schnittstelle wählen kann)
* JTAG mit AVRs
* Shift-/Schieberegister
* Sensorschaltung Windrichtung
* Sensorschaltung Luftfeuchte
* Schaltungssicherheitsvorkehrungen (wenns nicht nur auf dem Basteltisch funktionieren soll)
** ESD-Sicherheit
*** ESD-konformes Routing
*** ESD-Bauteile (Supressor Dioden, etc.)
*** Abschirmung bei Leitungen, Gehäuseauswahl, etc.
** Kurzschlusssicherheit
** Verpolungsschutz
** Überspannungsschutz
* Kondensator mit Beispielschaltungen
* Bluetooth Support (senden/empfangen) nach dem Vorbild des Lego NXT
* Microcontroller Entwicklungsboards
* Quarz-Bausteine: Funktionsprinzip und Beispielschaltungen (fehlt bisher komplett)

==Folgende erscheinen noch unvollständig und sollten von Usern die in dem Bereich kundig sind, ergänzt werden==
Findet man jetzt durch folgenden Link: [[:Kategorie:Artikelausbau]]
Artikel die unvollständig sind sollte man jetzt also nicht mehr hier aufgelistet werden, sondern die Artikel sollten am unteren Ende durch folgendes Kommando ergänzen werden:

<pre><nowiki>
{{Ausbauwunsch|Mehr Grundlagen und vor allem Programmbeispiele etc.}}
</nowiki></pre>

Im Artikel wird dann ein Hinweis eingeblendet, ähnlich wie diesem:

[[Bild:artikelausbau.gif]]

Also hier klicken um ausbaufähige Artikel zu finden:
* [[:Kategorie:Artikelausbau]]

----

Hier noch ein paar Artikel wo der Hinweis noch nicht drin steht:

* [[GNU Assembler|AVR Assembler (GNU) Einführung]]:
* [[Zahnrad]]
* [[Flipflop]]
* [[C-Tutorial]]
* [[Navigation]]
* [[Transistor]] (noch ein paar Bilder und vielleicht Grundschaltungen mit Beschreibung wären toll
* [[Avr-gcc|Dokumentation zu avr-gcc]]
* [[Arm]] Microcontroller
* [[GPS]] - Aufbau und Anwendung
* [[SPI]] - Vielleicht noch Beispiele
* [[Portexpander am AVR]] könnte nen BASCOM-Teil vertragen
* [[Manchester- Codierung]] - noch ein Programmbeispiel wäre toll
* [[JTAG]]

== Bereits erfüllte Wünsche ==
* stellenanzeigen-forum ->Gibt es bereits hier http://www.roboternetz.de/phpBB2/viewforum.php?f=29
* Filter (Hardware/Software) -> Wurde hier angelegt [[Filter (Elektronik)]]
* [[Roboterwettbewerbe]]
* Motortreiber (Einsteigerguide) -> [[Getriebemotoren Ansteuerung]]

[[Kategorie:RN-Wissen]]

Benutzer:RobotProgger

2008-03-30T17:04:17Z

RobotProgger:

Whats that? Ich bin ich, was denn sonst?
Ich bin 16 Jahre alt und beschäftige mich noch nicht lange mit Robotern, bin aber schon länger mit Elektronic am Werkeln
Nebenbei beschäftige ich mich noch mit Webdesign und Programmierung, sowohl von Windowsanwendungen als auch von Skripten für Homepages. So plane ich im Moment eine Community für Computerspieler, bei der ich das System komplett selbst programmiere. Im Moment beschäftige ich mich auch noch mit einer Tauschcommunity für Spielstände von PC-Spielen, die aber nicht so recht viele User anzieht.

Money, Money, immer das gleiche. Wenn es mal Geld regnen würde würde ich einen Quadrocopter bauen (so ca. €150-€200!) aber ich glaube ich muss mich mit einem kleinen primitiven Roboter begnügen, den ich in Planung habe

Benutzer:RobotProgger

2008-03-30T16:59:04Z

RobotProgger:

Whats that? Ich bin ich, was denn sonst?
Ich bin 16 Jahre alt und beschäftige mich noch nicht lange mit Robotern, bin aber schon länger mit Elektronic am Werkeln

Testseite

2008-03-30T16:57:29Z

RobotProgger:

= Testseite =

== Passive Bauteile ==
<math>
110^{-6}F
</math>

== Hier komme ich ==
Das will ich auch mal ausprobieren.

== da der rest ==

[[:Kategorie:Microcontroller]]

Hier kann man ein wenig experimentieren wie was geht! Einfach auf bearbeiten klicken und schreiben!
Wieso ist das jetzt in so einem Kästchen?
Eine neue Zeile im Haupttext.
So strukturiert man Seiten:
Bla ??? blablabla
Test1234
Das geht ja gut!!!

==Formeln==
<math> f(x)=x \cdot b^x </math>

<math> \sum_{k=0}^\infty \frac {(-1)^k \cdot x^{2k}}{(2k)!} </math>

<math> \sum_{k=0}^3 \frac {(-1)^k \cdot x^{2k}}{(2k)!} = 1-\frac{1}{2}\cdot x^2 +\frac{1}{24}\cdot x^4-\frac{1}{720}\cdot x^4</math>

<math>
U_\mathrm{m} = U_\mathrm{ein} \cdot \frac{t_\mathrm{ein}}{t_\mathrm{ein} + t_\mathrm{aus}}
</math>

----

----

== Neuer Abschnitt ==
bla bla bla ...

=== Unterabschnitt ===
bla bla bla ...
==== Unter-Unterabschnitt ====
[[Bild:AtmelController.jpg|thumb|Bildunterzeile für Beschreibung]]
bla bla bla ...
* Aufzählung
* Aufzählung
* Aufzählung
* Aufzählung

# Aufzählung <ref name="rrr"> aaa [xxxx yyy] </ref>
# Aufzählung
# Aufzählung
# Aufzählung

== Ab hier Testbereich zum ausprobieren - kann ruhig verschandelt werden!!!==

===Formatierprobleme===

;Quellcode I:
:<pre>Zeile 1
Zeile2
</pre>

----
{| {{Blauetabelle}}
|+ ohne center
|-
| a || b
|-
| aaaaaa || bbbbb
|}
----
{| {{Blauetabelle}} style="text-align:center;"
|+ mit center
|-
| a || b
|-
| aaaaaa || bbbbb
|}
----
{| style="text-align:center;" {{Blauetabelle}}
|+ mit center
|-
| a || b
|-
| aaaaaa || bbbbb
|}

== Formel ==

<math>E=mc^2</math>

http://images.allposters.com/images/GDF/Z1735D.jpg

==Vorlage==

:<math>
U(t) \,=\, U_0 \cdot e^{-\frac{t}{RC}}
</math>

{{Test|aaa|bbb}}

== Teste hier auch mal :-) ==
<math>\Downarrow\Uparrow</math>

== Hat du kopp wie Sieb mutdu aufschreiben ==
---------------------------

Interrupts

Struktur:

Config InterruptXXX ‘Konfiguriere Interrupt
Enable Interrupts ‘generell Interrupts zulassen
Enable InterruptXXX ‘schalte speziell den InterruptXXX ein
On InterruptXXX SprungXXX ‘verzweige bei InterruptXXX zu SprungXXX

Do
....Hauptprogramm ‘Hauptprogramm
Loop
End

SprungXXX: ‘Unterprogramm von InterruptXXX
....Ausführung ‘arbeitet hier etwas ab und springt mit Return
Return ‚ wieder zurück, zum Hauptprogramm
=== xxx ===
:<math>
\overline{u} \vee \overline{v} = \overline{u \wedge v}
</math>

:<math>
\bar{u}_1 \wedge \bar{u}_2 \wedge \cdots \wedge \bar{u}_n
= \overline{u_1 \vee u_2 \vee \cdots \vee u_n}
</math>

:<math>
\neg u_1 \wedge \neg u_2 \wedge \cdots \wedge \neg u_n
= \neg (u_1 \vee u_2 \vee \cdots \vee u_n)
</math>

:<math>
\bar{u} \vee u = 1
</math>

:<math>
\bar{u} \wedge u = 0
</math>

<math>
\bar{A_1} = \overline{A}_1 = \overline{A_1}
</math>

<math>\uparrow a</math>
|<math>\Downarrow \Uparrow</math>

== Jetzt will ich das ganze auch mal testen! ==
Test '''Test''' ''Test'' '''''Test'''''

<math>a² = b² + c²</math> 
 
<math>a=b+c</math> 

<math>a^2=b^2+c^2</math> 
*Dies könnte eine Aufzählung sein
**und dies einer der Inhalte
**dies auch
***und noch ein inhalt von "dies auch" 

nun will ich
auch einmal versuchen
ein quelltextfenster
darzustellen!

<div align="center">
{{FarbigerRahmen|
Wichtiger Text wird in der Mitte geschrieben 
und zusätzlich ROT umrahmt!
}}
</div>

=== NAND GATTER ===
<math> x=a \overline { acb } b</math>

=== NOR GATTER ===
<math> x=a \overline { v } b</math>

--[[Benutzer:Elayne|Elayne]] 16:20, 27. Dez 2007 (CET)

== Getiebe ==

=== Achsabstände ===
Das größte Problem bei selbstgebauten Getrieben ist die Bestimmung
der Achsabstände. 
Zu weite Abstände verursachen zum einen Schäden an den Zahnrädern 
und zu kurze Abstände sorgen dafür, dass sich das Getriebe, 
wenn überhaupt, nicht drehen lässt und auch schneller verschleißen kann.

Ein wichtiger Parameter, welcher zur Berechnung der Achsabstände benötigt wird, 
ist die Modulgröße oder auch Modulzahl genannt.

Für Zahnräder mit unbekannter Modulgröße gibt es Zahnradlehren,
welche das ermitteln des Modul's erleichtert ohne raten zu müssen

Der Abstand der Zahnradachsen lässt sich wie folgend ermitteln:

Anzahl der beiden Zahnradzähne (welche ineiandergreifen) zusammenzählen,
davon dann die Hälfte mit der Modulzahl multiplizieren.

=Quellen=

;Quelle1: blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah
:{|
<pre>
ghdjs gdjs dgjs
dgsjdghsj
dgsdhgjs
</pre>
|}

;Quelle2 und Quelle3: blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah blah
:{|
|valign="top"| '''Quelle2'''
<pre>
ghdjs gdjs dgjs
dgsjdghsj
dgsdhgjs
</pre>
|              
|valign="top"| '''Quelle3'''
<pre>
ghdjs gdjs dgjs
dgsjdghsj
dgsdhgjs
ghdjs gdjs dgjs
dgsjdghsjjavascript:insertTags('\'\'\'','\'\'\'','Fetter Text');
Fetter Text
dgsdhgjs
ghdjs gdjs dgjs
dgsjdghsj
dgsdhgjs
</pre>
|}

==Sudoku==

[[Bild:sodoku.gif|center]]

==Quellen==
<references/>

==Bildergallery ganz einfach anlegen==
<gallery>
Image:kaercherrobot.jpg
Image:siemensvsr8000unten.jpg|Siemens von unten
Image:siemensvsr8000buerste.jpg
Image:siemensvsr8000basis.jpg|Die Basisstation
</gallery>

[[Category:Test]]

[[Media:Beispiel.mp3]]

darf ich auch mal, ja? Gut:
L'''o'''r''e''m ipsum dolor sit amet.......