http://sites.schaltungen.at/arduino-uno-r3/programmierung ~015_b_PrennIng-a_arduino.uno.r3-programmierung (xx Seiten)_1a.pdf




DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE

         ARDUINO UNO R3 Programmierung     

              So einfach kann programmieren sein!
                       Arduino Uno Tutorial für die erste Benutzung
                                                  von Christian Sommer

300_c_C. Sommer-x_ARDUINO UNO Tutorial - So einfach kann programmieren sein! _1a.pdf

********************************************************I*

Mikrocontrollerspielwiese

Hier wird sich  um Mikrocontroller-Anfänger gekümmert

Man findest hier den kompletten Einstieg und man kann hier auch die Programmiersprache C lernen.

viele Beispielprojekte, um schnell und einfach Erfolgserlebnisse zu erlangen.
Es wird aber nicht das letzte Bit erklären und nicht jede mögliche Funktion erwähnt.
Die Hard- und Softwareprojekte stellen Ausgangspunkte dar, die Dir als Vorlagen für Deine eigenen, vielleicht viel größeren Projekte dienen sollen.

Was Du brauchst:
einwenig Vorwissen
einen Mikrocontroller
ein Steckbrett, um ihn draufzustecken (oder eine Universalleiterplatte/Lochrasterleiterplatte)
eine Spannungsversorgung
ein paar wenige Bauelemente
Software, um zu Programmieren
einen Programmieradapter, um Dein Programm in den Mikrocontroller zu schieben
Deine Bereitschaft, einwenig die Programmiersprache C zu lernen

Was kostet Dich das   ?  ungefähr > € 10,-



Programmieren lernen
1. Einwenig C lernen
2. C für Mikrocontroller
3. eigene Projekte
4. einige nützliche Unix Befehle




Projekte und Experimente

1. Los geht's
Hello World! (eine LED auf dem Arduino blinken lassen)
Was Du in jedem Arduino-Programm findest...

2. Arduino gibt digitale Signale aus
Was ist ein digitales Signal?
Das Blinksdings
Wechselblinker
3-Kanal-Lauflicht (Was sind Variablen?)
5-Kanal-Lauflicht (Was sind Ports?)
14-Kanal-Lauflicht (Was ist eine for-Schleife?)
14-Kanal-Hinundherlauflicht
Morse-Code: SOS (Was ist eine eigene Funktion?)
Zufallslicht (rand-Funktion)
Knightrider (if)
14-Kanal-Gummiballlauflicht (Bist Du ein Künstler?)
Alle Pins können digital
20-Kanal-Lauflicht
komische Zahlen (dez, bin, hex)
 
3. Arduino gibt analoge Signale aus
LED halbhell leuchten lassen - Was ist PWM?
Langsames Hell- und Dunkelwerden einer LED (Fading / analogWrite / PWM)
PWM an allen Pins
 
4. Arduino gibt Informationen auf LCD aus Text-LCD:
Hello World - Text-LCD!
Laufschrift
Arduino zählt die Sekunden (millis-Funktion)
Zeitanzeige
Digitaluhr
Umlaute und Sonderzeichen ausgeben
Eigene Symbole erschaffen und ausgeben
Kleine Animation (einzelner Pixel)
Kleine Animation (Mario)
Grafik-LCD:
Hello World - Grafik-LCD
Kleine Animation
Laufschrift
Variablen ausgeben
Große Schrift
Sechs Analogwerte anzeigen
Spannung und Stromstärke anzeigen
Joystick (Menü, mit Joystick bedienbar)

5. Arduino sendet Informationen an Deinen Computer
Hallo Computer! (Serial Monitor: Serial.print und Serial.println)

6. Arduino empfängt Informationen von Deinem Computer
Hallo Arduino LED! (Eingaben im Serial Monitor lassen die Board LED an- oder ausgehen)
Hallo Arduino LCD! (Eingaben im Serial Monitor lassen Text auf LCD erscheinen)

7. Arduino reagiert auf Tasteneingaben
Hallo Taste!
Logikfuntionen: AND, OR
Gegenseitige Auslösung
Gegenseitige Verriegelung (Quiz-Schaltung)
Zählen von Tastenbetätigungen / Entprellen
Zeitschalter (Treppenhausbeleuchtung / Monoflop)
Nur eine einzige Taste steuert das Leuchten einer LED
Taste löst Interrupt aus / nur eine einzige Taste steuert das Blinken einer LED
 
8. Arduino empfängt analoge Signale
Was ist ein Analogwert?
Analogwert messen und an den Computer senden
Analogwert steuert LED-Band-Anzeige
Analogwert steuert LED-Punkt-Anzeige (Was ist ein Makro?)
Analogwert als Batteriesymbol im LCD ausgeben
 
9. Arduino steuert Motoren
Servomotor
Gleichstrommotor / DC Motor
Servomotor als billiger Getriebemotorersatz z. B. für Roboter
Schrittmotor

10. Arduino programmiert seinen kleinen Bruder
Einen Attiny45 programmieren (ArduinoISP)
Puren avr-gcc benutzen, um einen Attiny45 zu programmieren

11. Arduino steuert eine LED-Matrix
Einen Punkt leuchten lassen
Zeilenlauflicht
Spaltenlauflicht
Alle 64 Punkte hintereinander leuchten lassen
Diagonallauflicht
Ein schräger Strich mit Multiplex
Ein Smiley zeigt Gefühle
Laufschrift

12. Arduino und sein Bruder reden miteinander
I2C: eine Sprache in der Mikrocontroller miteinander sprechen können
Text über I2C senden
Drei (oder mehr) Messwerte zu einem Slave mit LCD übertragen
 
13. Arduino erkennt seine Umwelt
Wie warm ist es?
Wie feucht ist es?
Wie groß ist der Abstand bzw. die Distanz?
Wie hell ist es?
Wie laut ist es?
Wie groß ist die Spannung?
Wie groß ist der Strom?
Wie groß ist der Widerstand?
Wie groß ist die Frequenz?

14. Arduino benutzt einen Timer
Wie man einen Timer benutzen kann
 
15. Arduino kommuniziert mit Deinem Computer mittels Frontends
C#:
Computer → Arduino:
Eine LED schalten (ein C# Programm läßt die Arduino LED an- und ausgehen)
Sechs LEDs schalten (ein C# Programm läßt 6 LEDs an- und ausgehen)
Zwölf LEDs schalten (ein C# Programm läßt 12 LEDs an- und ausgehen - zwei Bytes senden)
Eine LED dimmen (ein C# Programm steuert einen PWM-Ausgang des Arduino)
Sechs LEDs dimmen (ein C# Programm steuert die 6 PWM-Ausgänge des Arduino)

Arduino → Computer:
Sechs Analogwerte von Arduino an den Computer senden (ein C# Programm zeigt die Analogwerte an)

Java:
Wie geht serielle Datenübertragung mit Java?

Arduino → Computer:
Java-Programm zeigt die sechs Analogwerte als Zahlen an
Java-Programm zeigt die sechs Analogwerte als Balken an
Java-Programm zeigt die sechs Analogwerte als Zeiger an
Java-Programm zeigt die sechs Analogwerte als Kennlinien an

Computer → Arduino:
Ein Java-Slider sendet zum Arduino einen Wert, der im LCD ausgegeben wird
Ein Java-Slider sendet zum Arduino einen Wert, der die Helligkeit einer LED steuert (PWM)
Sechs Java-Slider senden 6 Werte zum Arduino-LCD
Sechs Java-Slider senden 6 Werte zum Arduino und steuern 6 LEDs mit PWM
Ein Java-Slider sendet zum Arduino einen Wert, der einen Servo steuert
Sechs Java-Slider steuern sechs Servos
Text von einem Java-Programm zum LCD senden
 
16. Arduino im Netzwerk (LAN und Internet)
Arduino als Webserver (Messwerte im Netz veröffentlichen)
Arduino als Webserver (über Netzwerk eine LED steuern)
Arduino als Webclient
Arduino postet auf Twitter
 
17. Arduino steuert Roboter
Finde das Licht!
Der lichtscheue Terror-Lutz
Fahre auf der schwarzen Linie!
Erkenne die Hindernisse!

Downloads:
Datenblatt des Mikrocontrollers vom Arduino Uno R3: Atmega328
Datenblatt der Mikrocontroller, die auch auf Arduinospielwiese benutzt werden: Attiny45 und Attiny85
Datenblätter weiterer Mikrocontroller gibt es auf der Mikrocontrollerspielwiese
Datenblätter für Motortreiber-ICs: L293D L298
Handbuch zur C-Befehlsbibliothek: avr-libc-user-manual
Schaltplan des Arduino Uno

Quelle:

http://www.arduinospielwiese.de/

********************************************************I*

Einführung in die Programmierung mit C und Arduino

• 1 Vorwort
• 2 Einführung in C
•   2.1 Datentypen
•     2.1.1 Arrays
•     2.1.2 Strings
•     2.1.3 Strukturen
•     2.1.4 Aufzählungstyp
•     2.1.5 Konstanten
•   2.2 Operatoren
•     2.2.1 Arithemtische Operatoren
•     2.2.2 Vergleichsoperatoren
•     2.2.3 Logische Operatoren
•     2.2.4 Bitorientierte Operatoren
•   2.3 Kontrollstrukturen
•     2.3.1 Verzweigung
•     2.3.2 for-Schleife
•     2.3.3 while-Schleife
•     2.3.4 do-while-Schleife
•     2.3.5 break and continue
•     2.3.6 switch-Anweisung
•   2.4 Zeiger (Pointer)
•   2.5 Funktionen
•     2.5.1 call-by-value
•     2.5.2 call-by-pointer
•     2.5.3 call-by-reference
•     2.5.4 Default-Parameter
•     2.5.5 Funktionen überladen
•   2.6 Formatierung
• 3 Einführung in Arduino
•   3.1 Software und Installation
•   3.2 Programmieren
•   3.2.1 Sketch
•    3.2.2 Digital I/O
•    3.2.3 Analog I/O
•    3.2.4 Zeit
•    3.2.5 Kommunikation
•    3.2.6 Mathe
•    3.2.7 Externe Interrupts
•   3.3 Boards
•    3.3.1 Arduino Uno
•    3.3.2 Arduino Mega
•   3.4 Beispiele

1 Vorwort

Diese Einführung entstand im Rahmen eines Semester Praktikums in China. Bei einem Projekt das über die Programmierung und den Aufbau eines Quadrocopters ging wurde mit einem Arduino gearbeitet. Um alle Projektmitglieder auf einen gemeinsamen Wissensstand zu bringen brauchte ich ein speziell für Arduino und C ausgelegte Einführung. Alle die ich im Internet dazu gefunden habe waren nicht vollständig und deckten nur kleine Teilgebiete ab. Gleichzeitig war das schreiben dieser Einführung eine gute Wiederholung für mich. Es soll für all-diejenigen sein, die etwas eingerostet sind in der Sprache C oder den Umgang mit einem Arduino lernen möchten. Wobei der Arduino schon sehr benutzerfreundlich ist und für Einsteiger im Mikrocontroller Bereich gilt, finden dennoch viele die ersten Schritte schwierig. Weil es sehr knapp gehalten wurde kann es auch als Nachschlagewerk für die Syntax genutzt werden.

2 Einführung in C

Es gibt immer mehr als eine Möglichkeit, eine Aufgabe in einem Computerprogramm abzubilden. Finde deinen eigenen Programmierstil und verbessere ihn. Ablauf eines Programms:

1. Präprozessing: Headerfiles(*.h) werden zum Quellfile hinzugefügt
2. übersetzen in Assemblercode: Hier wird ein Quelltextfile in der prozessorspezifischen Programmiersprache Assembler erzeugt.
3. Objektcode erzeugen: Hier wird aus dem Assemblerfile ein Hex-File generiert, welches die direkten Steuerbefehle für den Prozessor beinhaltet.
4. Linken: Alle Objektfiles und notwendigen Bibliotheken werden miteinander zum ausführbaren Programm verbunden.

2.1 Datentypen

Die Größe der Datentypen ist System abhängig und besonders bei Mikrocontroller sehr wichtig, da der Speicher begrenzt ist. Ein Bool ist eigentlich nur ein Bit groß dennoch wird dafür ein ganzes Byte reserviert, weil kleinere Datentypen nicht verarbeitet werden können.

Type	Vorzeichen	Anzahl Bit	Wertebereich
char	mit	8	Character-Zeichen 'A'
bool	ohne	8	false, true
byte	ohne	8	0-255
short	mit	16	-32 768 bis 32 767
word	ohne	16	0 bis 65 535
int	mit	16	-32 768 bis 32 767
unsigned int	ohne	16	0 bis 65 535
long	mit	32	-2 147 483 648 bis 2 147 483 647
unsigned long	ohne	32	0 bis 4 294 967 295
float	mit	32	6-7 Stellen insgesamt
double	mit	32	wie float

2.1.1 Arrays

In einem Array werden Daten gleichen Datentyps zusammengefasst. 

int x[3]; // Deklarationx[0] = 1; // 1. Elementx[1] = 2; // 2. Elementx[2] = 3; // 3. Elementint y[3] = {1, 2, 3}; // Kann auch bei der Deklaration festgelegt werdenfor(int i = 0; i < 3; i++) // array durchlaufen  x[i] = y[i]; // vorsicht: Element muss existieren!

2.1.2 Strings

Ein String ist nichts anderes als ein char-Array.

char str1[5] = {’T’, ’e’, ’s’, ’t’, ’\0’}; // \0 beendet den Stringchar str2[] = "Test"; // nach der Deklaration ist das Array 5 langchar str3[5] = "Test";char str4[15] = "Test"; // platz halten für einen größeren String

2.1.3 Strukturen

Die Struktur definiert einen neuen Datentyp, welcher Komponenten unterschiedlicher Datentypen beinhaltet

struct Auto // neue Struktur{  int gewicht;  int maxGeschwindigkeit;};Auto bmw;bmw.gewicht = 1600;bmw.maxGeschwindigkeit = 290;

2.1.4 Aufzählungstyp

Der Aufzählungstyp wird verwendet, wenn man Werte gruppieren möchte, aber ein Array zu unübersichtlich ist.

enum Tag{  montag, dienstag, mittwoch, donnerstag, freitag};Tag arbeitstag; // neue Variable Deklarierenarbeitstag = montag; // Variable zuweisenif (arbeitstag == montag){  // schlechte Laune}

2.1.5 Konstanten

Es gibt Konstanten mit Variablennamen. Dabei wird eine Variable zusätzlich mit dem Schlüsselwort const gekennzeichnet, so kann sie später im Programm nicht mehr verändert werden. Es gibt auch symbolische Konstanten. Hier wird zu Beginn ein Name festgelegt, der später beim Kompilieren durch den dazugehörigen Wert ersetzt wird.

// Symbolische Konstanten#define NL ’\n’#define Number 5#define Hello "Hello World\n"//Konstanten mir Variablennamenconst int N = 5;

2.2 Operatoren

2.2.1 Arithemtische Operatoren

Zu jeder arithmetischen Operation gibt es auch eine Kurzschreibweise, die aber mit bedacht verwendet werden sollte (führt aber zu schlecht lesbarem Code).

a = a + b; // Additiona += b;a = a - b; // Subtraktiona -=b;a = a * b; // Multiplikationa *=b;a = a / b; // Division (Vorsicht bei Integer)a /=b;a = a % b; // Modulo (Rest bei Division)a %= b;a = b++; // Post Inkrementa = ++b // Pre Inkrementa = b--; // Post Dekrementa = --b; // Pre Dekrement

2.2.2 Vergleichsoperatoren

Alle Operationen geben true oder false zurück.

int a = 3, b = 6;a < b; // a kleiner ba <= b; // a kleiner gleich ba > b; // a größer ba >= b; // a größer gleich ba == b; // a gleich b (Vorsicht bei Gleitkommazahlen)a != b; // a ungleich b (Vorsicht bei Gleitkommazahlen)if(a == b) // wenn erfüllt{  //..dann tue das}

2.2.3 Logische Operatoren

Alle Operationen geben true oder false zurück.

bool a = true;a = !a; // jetzt hat a den wert falsea = a && true // logisches UNDa = a || true // logisches ODER

2.2.4 Bitorientierte Operatoren

Alle Operatoren werden bitweise angewandt.

short int n = 6 // 0..000110 entspricht 6n = ~n; // Complement, d.h. jede 0 wird eine 1 und jede 1 eine 0n = n & 1 // bit-ANDn = n | 1 // bit-ORn = n ^ 1 // bit-XORn = n << 2 // shift left by 2n = n >> 2 // shift right by 2if ((n | 1) == n) // 10101 OR 00001 = 10101{  // zahl n ist ungerade}

2.3 Kontrollstrukturen

2.3.1 Verzweigung

Es wird überprüft, ob eine Bedingung erfüllt ist. Je nach dem wird ein anderer Code ausgeführt.

bool a = true;if(a == true){  // wenn a == true}else{  // wenn a == false}int c = (a > b) ? a : b // Kurzschreibweise ist aber offiziell ein Ternärer Operator

2.3.2 for-Schleife

Der Code im Block wird eine bestimmte Anzahl durchlaufen. Auf die Zählvariable kann innerhalb des Blocks zugegriffen werden.

for(int i=0; i<10; i++){  // dieser Code wird 10 mal ausgeführt}

2.3.3 while-Schleife

Der Code innerhalb des Blocks wird solange ausgeführt, wie die Bedingung im Kopf erfüllt ist.

while(a == true){  // dieser Code wird solange ausgeführt wie a gleich true ist}

2.3.4 do-while-Schleife

Dies ist die fußgesteuerte while-Schleife. Sie funktioniert wie die normale while-Schleife nur, dass die Bedingung am Schluss kommt. Der Vorteil ist, dass der Code unabhängig von der Bedingung mindestens einmal ausgeführt wird.

do {  // dieser Code wird mindestens einmal ausgeführt} while(a == true); // nicht das Semikolon vergessen!

2.3.5 break and continue

Diese beiden Anweisungen werden im Zusammenhang mit Schleifen verwendet. Vorsicht bei der Anwendung. break: der Aufruf dieser Anweisung beendet die gesamte Schleife. continue: Der Aufruf beendet nur den aktuellen Durchlauf an dieser Stelle und setzt die Codeausführung an dem Schleifenkopf fort.

int i = 0;for(;;){  i++; // i um 1 hochzählen  if(i % 2 == 0) // alle geraden Zahlen überspringen    continue; // den Rest vom Programmteil überspringen und beim Schleifen Kopf starten  if(i>1000) // nach 1000 durchläufen Schleife beenden    break;}

2.3.6 switch-Anweisung

Falls man einen Wert einer Variablen auf verschiedene Werte überprüfen möchte, ist die switch-Anweisung die beste Wahl.

int n = 7;switch(n){  case 3:    // falls n gleich 3 ist  break; // die Anweisung break beendet die switch-Anweisung  case 7:    // falls n gleich 7 ist  break;  default:    // Falls es auf kein Fall zu trifft  break;}

2.4 Zeiger (Pointer)

Zeiger zeigen auf ein Objekt eines jeden beliebigen Datentyps. Mit einem Sternchen vor dem Namen wird ein Zeiger beim Deklarieren gekennzeichnet. Er muss vom gleichen Datentyp sein, wie der, auf den er späte zeigen soll.

int n = 5 // Deklaration einer normalen Variablenint *ip; // Deklaration eines Zeigers der auf Integer zeigen kannip = &n; // Pointer wird initialisiert mit der Adresse der Variablen*ip = *ip + 2; // n wird mithilfe des Zeigers um 2 erhöhtstruct Auto // Struktur erstellen{  int maxGeschwindigkeit;};Auto bmw, *pBmw; // Anlegen einer Variablen und einem PointerpBmw = &bmw; // Pointer bekommt die Adresse von bmw(*pBmw).maxGeschwindigkeit = 290; // zugriff auf die VariablepBmw->maxGeschwindigkeit = 290; // bessere alternative

2.5 Funktionen

Wenn Programmabschnitte meist öfter als einmal benötigt werden, oder einfach nur der übersichtlichkeit halber, bietet sich eine Funktion an. Sie besteht aus dem Datentyp, welchen sie zurückgibt, dem Namen und der übergabeparameter. Doch zuerst muss man sie, wie auch bei den Variablen, bekannt geben.

int add(int a, int b); // Deklaration der Funktion meist außerhalb in einem Header Fileint add(int a, int b) // Definition der Funktion{  return (a + b);}int c = add(1, 2); // Aufruf der Funktion

2.5.1 call-by-value

void calcY(int y) // Definition der Funktion. Void bedeutet das diese Funktion nichts zurückgibt{  y = y + 2;}int y1 = 2;calcY(y1); // nach dem Aufruf hat die lokale Variable y1 immer noch den Wert 2

2.5.2 call-by-pointer

Falls die Übergabeparameter durch den Aufruf der Funktion verändert werden sollen, gibt es die Möglichkeit sie per Zeiger zu übergeben.

void swap (int *a, int *b){  int *tmp = a; // Variable wird temporär zwischen gespeichert  a = b;  b = tmp;  *tmp = (*a) + (*b); // Falls man auf die Werte zugreifen will}int x = 1, y = 2;swap(&x, &y); // nachdem Aufruf besitzt x den Wert 2, y den Wert 1

2.5.3 call-by-reference

ähnlich wie call-by-pointer, funktioniert call-by-reference. Man gibt nur die Speicheradresse der Variablen an die Funktion weiter.

void swap (int &a, int &b){  int tmp = a; // Variable wird temporär zwischen gespeichert  a = b;  b = tmp;}int x = 1, y = 2;swap(x, y); // nachdem Aufruf hat x den Wert 2 und y den Wert 1

2.5.4 Default-Parameter

Um bei einem Funktionsaufruf nicht alle Parameter angeben zu müssen, kann man die Variablen vor belegen.

int add(int a, int b, int c=0, int d=0); // muss bei der Deklaration geschehenadd(1, 2, 3, 4); // man muss nicht alle Parameter angeben, für die fehlenden wird der Defaultwert 0 übergebenadd(1, 2, 3);add(1, 2);

2.5.5 Funktionen überladen

Man kann den gleichen Namen einer Funktion verwenden, solange sie sich in der Parameterliste unterscheiden. Der Compiler entscheidet dann welche Funktion er verwenden muss.

int add(int a, int b); // Deklaration der add Funktion mit zwei Integer Parameterint add(int a, int b, int c); // Deklaration mit drei Parameter

2.6 Formatierung

Ein wichtiges Thema wird meist vergessen, die Formatierung.

• Bei der Benennung der Variablen werden wir dem CamelCase Style folgen. D.h. der Anfangsbuchstabe ist jeweils klein und jedes weitere Wort wird groß geschrieben.
• Wichtig ist es auch sein Code zu kommentieren. Zu Beginn eine kurze Beschreibung, welche Funktion diese Datei hat, den Autor und das Datum, sowie Kommentare im Code. Ein gut kommentierter Code ist zu 50% Grün.
• Außerdem ist es wichtig den Code übersichtlich zu gestalten und bei zu langen Ausdrücken in einer Zeile in mehrere Zeilen aufzuteilen.
• Bitte auch darauf achten, dass der Code einer Funktion keinen größeren Umfang als eine Seite hat.
• Jede neue Klasse sollte in einer neuen Datei geschrieben werden.

int meineZahl = 5;Auto einObjectDerKlasseAuto;x = 1/2(b^2 * sin(angle/PI)) // dies ist ein Kommentar/* ein Kommentar.... über mehrere Zeilen */if(a == true){b*=(a-b)%2} // kein Spaghetticode erzeugen

3 Einführung in Arduino

Arduino ist eine Open-Source-Plattform, basierend auf einem Mikrocontroller-Board und einer Entwicklungsumgebung. Warum Arduino? Arduino ist viel günstiger als so manches Entwickler Board. Sie sind leichter zu Programmieren als zum Beispiel die Atmel AVR Controller und es gibt eine große aktive Community.

3.1 Software und Installation

Arduino liefert eine eigene kleine Software die Ihr hier herunterladen könnt. Es existieren auch Plugins für Microsoft Visual Studio und Eclipse. Nach der Installation könt ihr auch schon gleich loslegen. Geht auf neuen Sketch erstellen (Programme in Arduino heißen Sketch). Dann wählt ihr noch den richtigen USB Port aus, unter Tools -> Serial Port. Nun muss noch das richtige Arduino Modell ausgewählt werden, unter Tools -> Board. Zum Schluss könnt ihr den Sketch hochladen.

// Beispiel Sketch - Blinkende LEDvoid setup() {                 pinMode(13, OUTPUT);     }void loop() {  digitalWrite(13, HIGH);  delay(1000);              digitalWrite(13, LOW);   delay(1000);  }

3.2 Programmieren

Man kann den Arduino in C und teilweise in C++ programmieren, wobei man bei C++ auf den begrenzten Speicher acht geben muss. Zusätzlich gibt es noch spezielle mikrocontroller-typische Befehle, wie zum Beispiel das Einlesen und Ausgeben eines Pins. Für eine detaillierte Erklärung bitte hier nachlesen.

3.2.1 Sketch

Als Sketch wird ein Programm bezeichnet. Es beinhaltet immer zwei Funktionen, nämlich setup und loop. Setup wird genau einmal ausgeführt und dient zur Deklarationen von Variablen. Loop ist wie eine endlos-Schleife. Sie wird nach jedem Durchlauf wieder von neuem aufgerufen.

void setup() {   // wird einmalig ausgeführt}void loop()  {  // Endlos-Schleife}

3.2.2 Digital I/O

Folgendes dient zur Manipulierung der Digitalen Pins. Zuerst muss man im setup bekanntgeben, ob der Pin als Eingang oder als Ausgang fungiert.

int val = 0;void setup(){  pinMode(13, OUTPUT);  // setzt den Pin 13 als Ausgang  pinMode(12, INPUT);  // setzt den Pin 12 als Eingang }void loop(){  val = digitalRead(12);  // einlesen des Digitalen Wert  digitalWrite(13, val);  // macht den Ausgang HIGH    delay(1000);  // 1s warten  digitalWrite(13, LOW);  // schaltet den Ausgang wieder auf LOW       }

3.2.3 Analog I/O

Für die Analogen Pins gilt fast das gleiche, wie bei den Digitalen Pins. Bei analogWrite wird der Wert in ein Rechtecksignal (PWM ca. 490Hz) umgewandelt, dass im Mittelwert dem gewünschten Analogen Wert entspricht.

void setup(){  pinMode(9, OUTPUT);   // Pin 9 unterstützt analogWrite()}void loop(){  int val = analogRead(3);   // Potentiometer einlesen  analogWrite(9, val >> 2);  // val muss von 0-1023 auf 0-255 angepasst werden}

3.2.4 Zeit

Für die Zeitgebung und die Verzögerung gibt es einige fertige Funktionen.

// 1 s = 1 000 ms = 1 000 000 ust = millis();  // gibt die Millisekunden zurück seit der Mikrocontroller läuft. (Datentyp läuft in 50 Tagen über)t = micros();  // gibt die zeit in Mikrosekunden zurück. Die Auflösung beträgt 4 us bei 16MHz (Datentyp läuft in 70 Minuten über)delay(t);  // verzögert das Programm um msdelayMicroseconds(t);  // verzögert um us

3.2.5 Kommunikation

Die Kommunikation mit dem Arduino erfolgt meist über einen Seriellen Port. Zum einen wird der Arduino darüber programmiert, zum anderen kann man auch mit ihm kommunizieren. Zum Beispiel Sensorwerte auslesen und direkt anzeigen. Um dies zu machen muss man zuerst den Serial Monitor aktivieren und die richtige Baudrate auswählen. Für weitere Funktionen bitte hier entnehmen.

void setup() {  Serial.begin(9600);  // Neue Kommunikation einrichten mit einer Baudrate von 9600}void loop() {  Serial.println(analogRead(0));  // den Analogen Pin0 einlesen und auf dem Serial Monitor ausgeben  delay(100);  // verzögerung von 100 ms}   

3.2.6 Mathe

In der Standard Bibliothek gibt es schon vorhandene Funktionen für die Berechnung. Bei der Verwendung immer darauf achten, dass der Mikrocontroller nicht viel Leistung hat.

minX = min(x1, x2);  // bestimmt die kleiner ZahlmaxX = max(x1, x2);  // bestimmt die größere zahlx = abs(a);  // berechnet den Absolutwertx = constrain(x, a, b);  // wird überprüft ob x innerhalb des Wertebereich liegt. Wenn x kleiner als a ist wird a zurückgegeben und wenn x größer als b ist wird b zurückgegeben.value= map(value, fromLow, fromHigh, toLow, toHigh);  // Wertebereich wird angepassta = pow(base, exponent);  // berechnet die Potenz einer Zahla = sqrt(x);  // berechnet die Wurzela = sin(a);  // berechnet den Sinus (Radiant)a = cos(a);  // der Rückgabewert ist auch Radianta = tan(a);randomSeed(analogRead(0));  // Den Zufallsgenerator abhängig von einem Eingang machen. Der Funktionsaufruf muss im setup erfolgenx = random(300);  // eine Zufallszahl zwischen 0 und 299 generierenx = random(10, 100);  // Zufallszahl liegt zwischen 10 und 99);

3.2.7 Externe Interrupts

Ein Interrupt ist wenn ein wichtiges Ereignis eintritt und das Hauptprogramm unterbrochen wird, um das Ereignis zu verarbeiten. Bei dem Arduino Uno gibt es zwei Externe Interrupts an Pin 2 und Pin 3. Man kann den Interrupt auslösen, wenn der Eingang auf LOW ist, sich ändert ( CHANGE ), wechselt auf high ( RISING ) oder auf low wechselt ( FALLING ). Die Interrupt Service Routine ist die Funktion, die den Interrupt verarbeitet. Sie sollte so knapp wie möglich geschrieben werden. Manche Funktionen werden nicht mehr weiterverarbeitet, wenn ein Interrupt aufgerufen wird (serielle Kommunikation). Falls Interrupts bei kritischen Sachen nicht erwünscht sind, kann man sie mit noInterrupts() deaktivieren und mit interrupts() wieder aktivieren.

volatile int state = LOW;  // falls die Funktion durch ein Interrupt verändert werden soll muss volatile angegeben werdenvoid setup(){  pinMode(13, OUTPUT);  // Pins 13 ist ein Ausgang  attachInterrupt(0, blink, CHANGE);  // Interrupt 0, Interrupt Service Routine, soll auf ein Wechsel reagieren  delay(60000);  // 60 s warten  detachInterrupt(0);}void loop(){  digitalWrite(13, state);}void blink()  // Interrupt Service Routine{  state = !state;}

3.3 Boards

3.3.1 Arduino Uno

Das meist verwendete Board heißt Arduino Uno. Aktuell in der dritten Revision ist es für fast jedes Projekt denkbar. Im Internet kursieren etliche Projekte und Anleitungen im Bezug auf den Arduino Uno. Es gibt zusätzlich einige Shields für dieses Board um die Funktionalität zu erweitern.

Spezifikation Arduino Uno R3

Microcontroller	ATmega328
Operating Voltage	5V
Digital I/O Pins	14 (6 davon haben PWM)
Analog Input Pins	6
Strom maximal I/O Pin	40 mA
Flash Memory	32 KB (0.5 KB Bootloader)
SRAM	2 KB
EEPROM	1 KB
Clock Speed	16 MHz

3.3.2 Arduino Mega

Wenn einem die Anschlüsse doch mal nicht reichen sollten dann ist die bessere Wahl der Arduino Mega. Mit zusätzlichem Speicher ist er gut für die großen Projekte ausgerüstet.

Spezifikation Arduino Mega R3

Microcontroller	ATmega1280
Operating Voltage	5V
Digital I/O Pins	54 (15 davon haben PWM)
Analog Input Pins	16
Strom maximal I/O Pin	40 mA
Flash Memory	128 KB (4 KB Bootloader)
SRAM	8 KB
EEPROM	4 KB
Clock Speed	16 MHz

3.4 Beispiele

Nun macht es hier wenig Sinn die gleichen Beispiele die es schon genügend im Internet gibt hier noch einmal auszutreten. Unter folgendem Link findet Ihr etliche gut beschriebene Tutorials die sich meist auf den Arduino Uno beziehen aber ohne Probleme auch mit dem Mega realisierbar sind.

Quelle:
http://manuel-jasch.de/post/einf%C3%BChrung-in-die-programmierung-mit-c-und-arduino/




DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]
ENDE