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

Arduino Tutorial

2012-09-19T19:44:03Z

Robo tom 24:

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Inhalt der Int-Variable: 2012
|}

'''Erklärung:'''
%d ist ein ''Formatzeichen'', wird bei der Bildchirmausgabe durch den Variableninhalt ersetzt
Formatzeichen: 
%d - Int und Long Variablen 
%f - Float 
%lf - double 
%s - Zeichenkette (String) 

==== Mehrere Variablen ausgeben ====
Es können natürlich auch mehrere Variablen auf einmal ausgegeben werden:
<pre>
zweite_variable=1.234;
printf("Erste Variable: %d \n Die Zweite Variable steht in der nächsten Zeile: %f", variablenname, zweite_variable);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Erste Variable: 2012 Die Zweite Variable steht in der nächsten Zeile: 1.234
|}

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
Wenn man mehrere Variablen ausgibt werden die gleichen Positionen verwendet, d.h. für das erste Formatzeichen wird auch die erste nachstehende Variable verwendet, für das zweite Formatzeichen dann die zweite Variable.
|}

== Kommentare ==
Um Programme so lesbar wie möglich zu gestalten kann man verschiedene Kommentare hinzufügen:
* //Kommentartext Dieser Kommentar gilt ''nur bis zum Zeilenende'' der selben Zeile
* /* Kommentartext */ Dieser Kommentar gilt zwischen den beiden Symbolen und kann auch über ''mehrere Zeilen'' gehen

== Kontrollstrukturen ==
Zum Überprüfen und Vergleichen von Werten gibt es spezielle Funktionen
Die wohl wichtigste Kontrollstruktur ist die ''if-Abfrage''

=== if - Abfrage ===
'''Syntax:'''
<pre>
if(Abfragewert Operator Vergleichswert)
{
//Ausführung wenn Abfrage zutrifft
}
else
{
//Ausführung wenn Abfrage NICHT zutrifft
}
</pre>

'''Erklärung:'''
Der Operator ist ein sogenannter Vergleichsoperator: 
== ist gleich (Wahr, wenn beide Seiten gleich) 
> Größer (Wahr, wenn Abfragewert größer Vergleichswert) 
>= Größer Gleich (Wahr, wenn Abfragewert größer oder gleich Vergleichswert) 
< Kleiner (Wahr, wenn Abfragewert kleiner Vergleichswert) 
< Kleiner Gleich (Wahr, wenn Abfragewert kleiner oder gleich Vergleichswert) 
!= Ungleich (Wahr, wenn Abfragewert ungleich Vergleichswert) 

'''Beispiel:'''
<pre>
//Hier wurde eine Zahl mittels scanf eingelesen

if(zahl > 0) //Jetzt wird überprüft ob die Zahl größer als 0 ist, somit positiv
{
printf("Zahl ist Positiv"); //Wenn das zurtrifft wird "Positiv" ausgegeben
}
else
{
printf("Zahl ist negativ"); //Wenn nicht, wird "Negativ" ausgegeben
}
</pre>

'''Man kann auch mehrere Abfragen miteinander verknüpfen:'''
<pre>
//Beispiel: Es soll herausgefunden werden, ob eine Zahl positiv oder 0 ist.
//Wenn dies nicht zutrifft soll geprüft werden ob die Zahl kleiner oder gleich -10 ist

//Hier wurde die Zahle eingelesen

if(zahl >= 0) //Prüfen ob Zahl positiv
{
printf("Zahl positiv")
}
else if(zahl <= -10) //ACHTUNG: Das hier wird NUR geprüft wenn die erste Abfrage NICHT wahr ist
{
printf("Zahl kleiner als -10");
}
</pre>

//Logische Operatoren ( && || ! )

=== switch/case Abfrage ===
//Mehrfachabrage usw...

= µC - Programmierung =
== Über das Board ==
//In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

= Über das Tutorial =
== Dauer ==
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

== Projekte ==
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

== Autor ==
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

== Diskussionen über das Tutorial ==
[http://www.roboternetz.de/community/threads/59197-Diskussionsthread-Arduino-Tutorial-RN-Wiki-Artikel?referrerid=53900 Diskussionsthread]

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-13T19:35:17Z

Robo tom 24: Erweiterung (Kontrollstrukturen)

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist (in ca. 1 Woche *11.09.2012*)
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Inhalt der Int-Variable: 2012
|}

'''Erklärung:'''
%d ist ein ''Formatzeichen'', wird bei der Bildchirmausgabe durch den Variableninhalt ersetzt
Formatzeichen: 
%d - Int und Long Variablen 
%f - Float 
%lf - double 
%s - Zeichenkette (String) 

==== Mehrere Variablen ausgeben ====
Es können natürlich auch mehrere Variablen auf einmal ausgegeben werden:
<pre>
zweite_variable=1.234;
printf("Erste Variable: %d \n Die Zweite Variable steht in der nächsten Zeile: %f", variablenname, zweite_variable);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Erste Variable: 2012 Die Zweite Variable steht in der nächsten Zeile: 1.234
|}

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
Wenn man mehrere Variablen ausgibt werden die gleichen Positionen verwendet, d.h. für das erste Formatzeichen wird auch die erste nachstehende Variable verwendet, für das zweite Formatzeichen dann die zweite Variable.
|}

== Kommentare ==
Um Programme so lesbar wie möglich zu gestalten kann man verschiedene Kommentare hinzufügen:
* //Kommentartext Dieser Kommentar gilt ''nur bis zum Zeilenende'' der selben Zeile
* /* Kommentartext */ Dieser Kommentar gilt zwischen den beiden Symbolen und kann auch über ''mehrere Zeilen'' gehen

== Kontrollstrukturen ==
Zum Überprüfen und Vergleichen von Werten gibt es spezielle Funktionen
Die wohl wichtigste Kontrollstruktur ist die ''if-Abfrage''

=== if - Abfrage ===
'''Syntax:'''
<pre>
if(Abfragewert Operator Vergleichswert)
{
//Ausführung wenn Abfrage zutrifft
}
else
{
//Ausführung wenn Abfrage NICHT zutrifft
}
</pre>

'''Erklärung:'''
Der Operator ist ein sogenannter Vergleichsoperator: 
== ist gleich (Wahr, wenn beide Seiten gleich) 
> Größer (Wahr, wenn Abfragewert größer Vergleichswert) 
>= Größer Gleich (Wahr, wenn Abfragewert größer oder gleich Vergleichswert) 
< Kleiner (Wahr, wenn Abfragewert kleiner Vergleichswert) 
< Kleiner Gleich (Wahr, wenn Abfragewert kleiner oder gleich Vergleichswert) 
!= Ungleich (Wahr, wenn Abfragewert ungleich Vergleichswert) 

'''Beispiel:'''
<pre>
//Hier wurde eine Zahl mittels scanf eingelesen

if(zahl > 0) //Jetzt wird überprüft ob die Zahl größer als 0 ist, somit positiv
{
printf("Zahl ist Positiv"); //Wenn das zurtrifft wird "Positiv" ausgegeben
}
else
{
printf("Zahl ist negativ"); //Wenn nicht, wird "Negativ" ausgegeben
}
</pre>

'''Man kann auch mehrere Abfragen miteinander verknüpfen:'''
<pre>
//Beispiel: Es soll herausgefunden werden, ob eine Zahl positiv oder 0 ist.
//Wenn dies nicht zutrifft soll geprüft werden ob die Zahl kleiner oder gleich -10 ist

//Hier wurde die Zahle eingelesen

if(zahl >= 0) //Prüfen ob Zahl positiv
{
printf("Zahl positiv")
}
else if(zahl <= -10) //ACHTUNG: Das hier wird NUR geprüft wenn die erste Abfrage NICHT wahr ist
{
printf("Zahl kleiner als -10");
}
</pre>

//Logische Operatoren ( && || ! )

=== switch/case Abfrage ===
//Mehrfachabrage usw...

= µC - Programmierung =
== Über das Board ==
//In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

= Über das Tutorial =
== Dauer ==
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

== Projekte ==
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

== Autor ==
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

== Diskussionen über das Tutorial ==
[http://www.roboternetz.de/community/threads/59197-Diskussionsthread-Arduino-Tutorial-RN-Wiki-Artikel?referrerid=53900 Diskussionsthread]

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-13T09:50:34Z

Robo tom 24: Erweiterung

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist (in ca. 1 Woche *11.09.2012*)
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Inhalt der Int-Variable: 2012
|}

'''Erklärung:'''
%d ist ein ''Formatzeichen'', wird bei der Bildchirmausgabe durch den Variableninhalt ersetzt
Formatzeichen: 
%d - Int und Long Variablen 
%f - Float 
%lf - double 
%s - Zeichenkette (String) 

==== Mehrere Variablen ausgeben ====
Es können natürlich auch mehrere Variablen auf einmal ausgegeben werden:
<pre>
zweite_variable=1.234;
printf("Erste Variable: %d \n Die Zweite Variable steht in der nächsten Zeile: %f", variablenname, zweite_variable);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Erste Variable: 2012 Die Zweite Variable steht in der nächsten Zeile: 1.234
|}

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
Wenn man mehrere Variablen ausgibt werden die gleichen Positionen verwendet, d.h. für das erste Formatzeichen wird auch die erste nachstehende Variable verwendet, für das zweite Formatzeichen dann die zweite Variable.
|}

= µC - Programmierung =
== Über das Board ==
\\In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

= Über das Tutorial =
== Dauer ==
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

== Projekte ==
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

== Autor ==
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

== Diskussionen über das Tutorial ==
[http://www.roboternetz.de/community/threads/59197-Diskussionsthread-Arduino-Tutorial-RN-Wiki-Artikel?referrerid=53900 Diskussionsthread]

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-12T19:11:56Z

Robo tom 24:

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist (in ca. 1 Woche *11.09.2012*)
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Inhalt der Int-Variable: 2012
|}

'''Erklärung:'''
%d ist ein ''Formatzeichen'', wird bei der Bildchirmausgabe durch den Variableninhalt ersetzt
Formatzeichen:
%d - Int und Long Variablen
%f - Float
%lf - double
%s - Zeichenkette (String)

==== Mehrere Variablen ausgeben ====
Es können natürlich auch mehrere Variablen auf einmal ausgegeben werden:
<pre>
zweite_variable=1.234;
printf("Erste Variable: %d \n Die Zweite Variable steht in der nächsten Zeile: %f", variablenname, zweite_variable);
</pre>
Bildschirmausgabe:

{|{{Blauetabelle}}
|
Erste Variable: 2012 Die Zweite Variable steht in der nächsten Zeile: 1.234
|}

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
Wenn man mehrere Variablen ausgibt werden die gleichen Positionen verwendet, d.h. für das erste Formatzeichen wird auch die erste nachstehende Variable verwendet, für das zweite Formatzeichen dann die zweite Variable.
|}

= µC - Programmierung =
== Über das Board ==
\\In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

= Über das Tutorial =
== Dauer ==
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

== Projekte ==
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

== Autor ==
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

== Diskussionen über das Tutorial ==
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-12T16:31:09Z

Robo tom 24:

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist (in ca. 1 Woche *11.09.2012*)
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>
Bildschirmausgabe:

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
abjsdlfkjb
|}

'''Erklärung:'''
%d ist ein ''Formatzeichen'', wird bei der Bildchirmausgabe durch den Variableninhalt ersetzt
Formatzeichen:
%d - Int und Long Variablen
%f - Float
%lf - double
%s - Zeichenkette (String)

==== Mehrere Variablen ausgeben ====
Es können natürlich auch mehrere Variablen auf einmal ausgegeben werden:
<pre>
zweite_variable=1.234;
printf("Erste Variable: %d \n Die Zweite Variable steht in der nächsten Zeile: %f", variablenname, zweite_variable);
</pre>
Bildschirmausgabe:
{|{{Blaueschmaltabelle}}
|Erste Variable: 2012 Die Zweite Variable steht in der nächsten Zeile: 1.234|}

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
Wenn man mehrere Variablen ausgibt werden die gleichen Positionen verwendet, d.h. für das erste Formatzeichen wird auch die erste nachstehende Variable verwendet, für das zweite Formatzeichen dann die zweite Variable.|}

= µC - Programmierung =
== Über das Board ==
\\In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

= Über das Tutorial =
== Dauer ==
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

== Projekte ==
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

== Autor ==
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

== Diskussionen über das Tutorial ==
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-11T21:02:38Z

Robo tom 24:

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist (in ca. 1 Woche *11.09.2012*)
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>

= µC - Programmierung =
== Über das Board ==
\\In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

= Über das Tutorial =
== Dauer ==
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

== Projekte ==
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

== Autor ==
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

== Diskussionen über das Tutorial ==
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-11T20:59:08Z

Robo tom 24: Erweiterung

Dieses mehrwöchige/mehrmonatige Tutorial soll einem den Einstieg in die Welt der Mikrocontroller mit Hilfe des Arduino 2560 R3 Boards erleichtern. Angefangen wird natürlich bei den Grundlagen, also bei der Hochsprache "C". Das Tutorial ist chronologisch aufgebaut und kann ohne jegliche Vorkenntnisse abgearbeitet und (hoffentlich) verstanden werden
{{FarbigerRahmen|
'''In Bearbeitung''' - Tutorial wird dann regelmäßig geschrieben wenn die Basis da ist (in ca. 1 Woche *11.09.2012*)
}}

= Aller Anfang... =
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

= Wir starten mit C =
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden. Ebenso werden wir einige Bereiche nur überfliegen und nicht bis ins letzte Detail erklären, für das gibt es dann facheinschlägige Internetseiten und (ja man glaubt es kaum) Bücher.

== Hello World und der Grundaufbau ==
Ein C Programm besteht grundsätzlich aus 2 Hauptteilen:
# Hauptprogramm
# Include-Datein

<pre>
#include <eine_datei.h> //Include Datei
#include "eine_andere_datei.h>

void main() //Hier fängt das Hauptprogramm an
{
//Funktionsaufruf
}
</pre>

Diese paar Zeilen Code sind bereits ein lauffähiges, ausführbares Programm, unsere Konsolenanwendung bleibt aber leer, da wir keine Funktionen aufrufen.

Gleich vorweg: "//" ist ein Kommentar -> Keine Auswirkung auf den Programmablauf - mehr dazu später

=== Include Dateien ===
Die Inlcude Datein sind jene Datein, in denen Funktionen genauer definiert sind. Also wie die Funktion aufgerufen werden muss

Dateien, die im Standart Include Verzeichniss sind werden in spitze Klammern geschrieben (<...>), Dateien welche im Projektverzeichniss sind werden in doppelte Hochkomma geschrieben ("..."), diese Dateien werden von uns selbst geschrieben, z.B. um große Unterprogramme auslagern zu können

Häufig genutzte Dateien sind (im Windows-Bereich): 
*conio.h - Character Funktionen (getch etc) 
*stdio.h - Standart Ein-Ausgabe (printf, scanf etc) 
*stdlib.h - Zufallsfunktionen, CMD-Funktion 

=== Hauptprogramm ===
Das Hauptprogramm wird bei jedem Programmaufruf aufgerufen und abgearbeitet, ist das Hauptprogramm zu Ende, beendet sich das ganze Programm (Konsolenanwendung)
Das Hauptprogramm selbst besteht ebenso aus mehreren Teilen:
# Der Funktionskopf:
<pre>
void main ()
</pre>
Hier steht der Name, bei einem Hauptprogramm immer ''main'', bei Unterprogrammen (dazu später) kann man diesen frei wählen
Das ''void'' sagt aus, dass das Programm nichts zurück liefert, Unterprogramme können aber auch etwas zurückliefern, dazu ebenso später.

# Der Funktionsaufruf:
<pre>
{
//Funktionsaufruf
}
</pre>
Zwischen den geschwungenen Klammern wird das Programm abgearbeitet, also Berechnungen usw. ausgeführt

=== Ausgabe am Bildschirm ===
Die Standartausgabe am Bildschirm erfolgt über die Funktion ''printf''

Syntax:
<pre>
printf("Ausgabetext unter doppeltem Hochkomma", Variablen);
</pre>
Für die Formatierung und einige Zusatzfunktionen gibt es sogenannte Escape Sequenzen. Diese werden einfach in den Text eingeaut, die wichtigsten sind: 
* \n Nächste Zeile 
* \t Tabulator (horizontal) 
* \a Alarmton (Beep)

=== Hello World ===
Mit diesen einfachen Funktionen können wir nun unser erstes "sinnvolles" Programm schreiben:
<pre>
#include <stdio.h>

void main ()
{
printf("Hello World!");
}
</pre>
Bei Verwendung des Microsoft Visual Studios wird unser Programm einfach mit der Tastenkombination [Strg]+[F5] gestartet

== Variablen ==
Variablen werden verwendet um veränderbare (variable) Werte zu speichern.
Diese Werte können unterschiedlich groß sein, deshalb gibt es unterschiedliche Datentypen:

Ganzzahlige Variablen:
NAME WERTEBEREICH SPEICHERBEDARF
signed char -128 bis 127 1 Byte
unsigned char 0 bis 255 1 Byte
short int -32768 bis 32767 2 Byte
unsigned short int 0 bis 65535 2 Byte
int -32768 bis 32767 2 Byte
unsigned int 0 bis 65535 2 Byte
long int -2147483648 bis 2147483647 4 Byte
unsigned long int 0 bis 4294967296 4 Byte

Gleitkomma Variablen:
NAME WERTEBEREICH GENAUIGKEIT SPEICHERBEDARF
float 1.2 * 10-38 bis 3.4 * 1038 6 Stellen 4 Bytes
double 2.3 * 10-308 bis 1.7 * 10308 15 Stellen 8 Bytes
long double 3.4 * 10-4932 bis 1.1 * 104932 19 Stellen 10 Bytes

=== Variablen definieren/deklarieren/initialisieren ===
==== Definition - Deklaration ====
Als erster Schritt müssen Variblen definiert werden: es muss Name und Datentyp festgelegt werden, automatisch dazu wird ein gewisser Speicherplatz für die Variable reserviert.

Eine Definition einer Integer Variable könnte zum Beispiel so aussehen:
<pre>
int variablenname;
</pre>
Somit haben wir für die Variable "variablenname" einen 2 Byte großen Speicherplatz ''reserviert''.

==== Initialisierung ====
Nun schreiben wir ''erstmals'' Daten in unseren Speicherbereich.
<pre>
variablenname = 2012;
</pre>

{|{{Blaueschmaltabelle}}
|'''Merke:''' 
'''Deklaration''' ist nur die Vergabe eines Namens und eines Typs für die Variable. 
'''Definition''' ist die Reservierung des Speicherplatzes. 
'''Initialisierung''' ist die Zuweisung eines ersten Wertes.
|}

==== Alles auf einmal ====
Die Deklaration und Initialisierung kann auch auf einmal geschehen:
<pre>
int variablenname = 2012;
</pre>

=== Variablen ausgeben ===
Mit printf werden auch die Werte von Berechnungen ausgegeben:
<pre>
//anderer Programmcode
printf("Inhalt der Int-Variable: %d", variablenname);
</pre>

= µC - Programmierung =
== Über das Board ==
\\In Arbeit

= Begriffserklärungen =
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

== Über das Tutorial ==
=== Dauer ===
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

=== Projekte ===
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

=== Autor ===
* Thomas PAIL, Geb.: 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

=== Diskussionen über das Tutorial ===
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

= Schriften =
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-11T19:46:52Z

Robo tom 24:

Arduino Tutorial

2012-09-11T19:25:45Z

Robo tom 24: Erweiterung

Arduino Tutorial

2012-09-11T18:03:19Z

Robo tom 24: Erweiterung

Arduino Tutorial

2012-09-11T16:55:59Z

Robo tom 24: Erweiterung

Arduino Tutorial

2012-09-11T16:47:35Z

Robo tom 24: Erweiterung

Arduino Tutorial

2012-09-11T16:42:48Z

Robo tom 24: Erweitern

== Aller Anfang... ==
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden
Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

== Wir starten mit C ==
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden

== µC - Programmierung ==
=== Über das Board ===
\\In Arbeit

== Begriffserklärungen ==
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

== Über das Tutorial ==
=== Dauer ===
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

=== Projekte ===
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

=== Autor ===
* Thomas PAIL, 1996, Schüler HTLuVA Pinkafeld - Elektronik und technische Informatik
* Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

=== Diskussionen über das Tutorial ===
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

== Schriften ==
# Platzhalter

[[Kategorie:Microcontroller]]
[[Kategorie:Software]]
[[Kategorie:Grundlagen]]
[[Kategorie:Quellcode C]]

Arduino Tutorial

2012-09-11T16:41:36Z

Robo tom 24:

Arduino Tutorial

2012-09-11T16:37:25Z

Robo tom 24:

== Aller Anfang... ==
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden
Aus eigener Erfahrung: Keine Angst vor neuem!
Das was wir hier machen ist (mehr oder weniger) ungefährlich und es kann nichts kaputt werden. Es sollte aber alles Punkt für Punkt beachtet und lieber zweimal gelesen werden, bevor man etwas falsch macht.

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Anwenden von Arduino-Bibliotheken ''(eher weniger)''
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

=== Was gebraucht wird ===
Für das Tutorial wird das '''Arduino 2560 R3''' Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwenden wir die Freeware '''"Atmel Studio 6.0"''' und '''"WinAVR"''' zum übertragen auf den Controller. Für das C-Tutorial werden wir aber das '''"Microsoft Visual C++ Express"''' verwenden , das ebenso kostenlos ist.

'''Zusammenfassung:'''
* Arduino 2560 R3 Mikrocontrollerboard
* USB A auf B Kabel ("Normaler" USB Anschluss auf den abgeschrägten Quadratischen)
* PC/Notebook mit USB-Anschluss zum Programmieren
* IDE: Atmel Studio 6.0
* Übertragungsprogramm: WinAVR
* C - IDE: Microsoft Visual C++ Express

== Wir starten mit C ==
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, solche Funktionen werde ich dann erklären, wenn sie gebraucht werden

== µC - Programmierung ==
=== Über das Board ===
\\In Arbeit

== Begriffserklärungen ==
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

== Über das Tutorial ==
=== Dauer ===
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

=== Projekte ===
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

=== Autor ===
Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

=== Diskussionen über das Tutorial ===
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

== Schriften ==
# Platzhalter

Arduino Tutorial

2012-09-11T16:14:03Z

Robo tom 24:

== Aller Anfang... ==
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade neu einsteigen und mit wenig Hardware viel erreichen wollen. Es wird keine vorherigen Kenntnisse benötigt, ein wenig Zeit und technisches Interesse sollte jedoch mitgebracht werden

== Grundlegendes ==
=== Ziele ===
* Verstehen und Anwenden von Mikrocontrollern
* Verstehen und Anwenden der Hochsprache "C", genauer "AVR-GCC"
* Ansteuern von Peripheriegeräten im Zusammenhang mit µC:
** LED
** Relais
** usw.
* Auslesen von Sensoren mit µC:
** Temperatursensoren (PT1000, KTY81, etc)
** Lichtschranken (z.B. zu Drehzahlmessung)
** usw.

Was gebraucht wird:
Für das Tutorial wird das Arduino 2560 R3 Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.
Als integrierte Entwicklungsumgebung (IDE) verwende ich das "Atmel Studio 6.0" und "WinAVR" zum übertragen auf den Controller.

== Wir starten mit C ==
Für alle Neulinge die komplett neu in die Materie einsteigen gibts es am Anfang ein kleines C - Tutorial. Dies will ich aber nicht zu tief greifend machen, denn viele Funktionen wie Strings werden nur in Verbindung mit einem LCD bzw. einer Seriellen Schnittstelle gebraucht, diese Funktionen werde ich dann erklären, wenn sie gebraucht werden

== Begriffserklärungen ==
'''C'''
* CPU = '''C'''entral'''P'''rocessing'''U'''nit, Hauptprozessor
'''I'''
* IDE = '''I'''ntegrated'''D'''evelopment'''E'''nvironment, integrierte Entwicklungsumgebung, bestehend aus: Texteditor, Präprozessor, Compiler, Linker, Debugger
'''M'''
* Mikrocontroller = IC (Krabbelkäfer) der aus einer CPU, RAM, Flash-Speicher, Timer usw. zusammensetzt ist
'''R'''
* RAM = '''R'''andom-'''A'''ccess '''M'''emory, Speicher auf den laufend direkt zugegriffen werden kann, Arbeitsspeicher

'''Sonderzeichen'''
* µC = Mikrocontroller

== Über das Tutorial ==
=== Dauer ===
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze aber, dass wir Ende des Schuljahres (Juli 2013) von den Grundzügen, über Timer/Interrupts bis hin zur seriellen Schnittstelle kommen sollten.

=== Projekte ===
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais, Schalter usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.

=== Autor ===
Für Infos und Kontakt:
[http://www.roboternetz.de/community/members/53900-robo_tom_24 robo_tom_24 RoboterNetz - Profil]

=== Diskussionen über das Tutorial ===
Es wird noch ein Diskussions/Fragen/Antworten Thread im Roboternetz erstellt, Link folgt...

== Schriften ==
# Platzhalter

Arduino Tutorial

2012-09-11T15:30:33Z

Robo tom 24: Lernen und Verstehen eines µC mit dem Arduino 2560 Board

== Aller Anfang... ==
..ist gar nicht mal so schwer.
Dieses Tutorial soll all jenen helfen, die gerade einsteigen und mit wenig Hardware viel erreichen wollen

=== Grundlegendes ===
Was gebraucht wird:
Für das Tutorial wird das Arduino 2560 R3 Board verwendet, dazu wird noch eine externe Spannungsversorgung wenn man viel Peripherie angschlossen hat und ein USB Kabel benötigt.

== Über das Tutorial ==
=== Dauer ===
Eine Ende ist vorerst nicht in Sicht, es wird mehr oder weniger gleich wie in der Schule vorgegangen. Ich schätze daher, dass wir
=== Projekte ===
Geplant ist ein schrittweiser Aufbau mit einem Mix aus Lernstoff und praktischen Beispielen/Projekten, wobei bei diesen Projekten meistens nur "Standarthardware" (LEDs, Transistoren, Relais usw) verwendet wird. Es kann aber auch mal vorkommen, dass mehr Teile benötigt werden, dass wird dann (wenn möglich) aber eher als Zusatzbeispiel gemacht. Sollte es sich nicht vermeiden lassen externe Hardware anzuschaffen werd ich versuchen, dies so früh wie möglich anzukündigen.