Arduino – Einführung

Dies ist der erste Teil einer Arduino-Reihe.
Aufgrund aktueller Projekte habe ich wieder vermehrt mit Arduino zu tun, so dass ich in meinen Unterlagen von 2016 rumsuchen und experimentieren musste – also wollte ich meine Unterlagen in diesem Zuge gleich mit digitalisieren.

Meine Projekte führe ich zum Großteil mit dem Arduino Nano durch – einfach aus dem Grund weil es diese Boards im China-Shop im 10er Pack recht günstig gibt.
Normalerweise fangen die Leute mit dem Arduino Uno an – beide Boards (Uno und Nano) unterscheiden sich aber kaum von der Technischen Seite.
Hier der Offizielle Link zum Arduino Uno: https://store.arduino.cc/arduino-uno-rev3
Und hier zum Arduino Nano: https://store.arduino.cc/arduino-nano

Der größte unterschied den man auf dem ersten Blick sieht ist wohl die Größe des Boards an sich.
Der Arduino Nano eignet sich eher für die Steckbrett-Versuche aufgrund der Breadboard-kompatiblen Größe.

Okay.. dann fangen wir mal an.
Wir haben jetzt im Idealfall einen Arduino Uno oder Nano vor uns liegen, ein Steckbrett, ein paar Kabel, ein paar LED´s und ein paar Wiederstände (dazu später mehr).

Wie fangen wir nun an?
Als erstes brauchen wir eine Software um die Programme zu schreiben die später auf den Arduino laufen sollen.
Hierfür nutzt man Standardmäßig die Arduino-IDE welche man in der Version 1.8.5 unter https://www.arduino.cc/download_handler.php?f=/arduino-1.8.5-windows.zip als portable Version herunterladen kann.
Diese habe ich bei mir in das Verzeichnis C:\Arduino\arduino-1.8.5 gelegt. Dort drin befindet sich nun die IDE, welche wir über die Arduino.exe aufrufen können.

Sobald man die IDE Aufgerufen hat, bekommt man einen neuen Sketch angezeigt.
Sketche nennt man die Programme, welche man mit der Arduino-IDE schreibt.
Der neue Sketch sieht dann in etwa so aus:

1
2
3
4
5
6
7
8
9
void setup() {
  // put your setup code here, to run once:
 
}
 
void loop() {
  // put your main code here, to run repeatedly:
 
}

Im Prinzip gibt es eine setup() Funktion in der man alle relevanten Einstellungen VOR dem Programmstart hinterlegt – und es gibt eine loop(), also eine Endlosschleife, welche immer wieder durch den Arduino aufgerufen wird.
Nun kennen wir auch das Funktionsprinzip des Arduinos – alles wird in einer Endlosschleife ausgeführt.

Um das etwas genauer zu sehen, öffnen wir eines der vielen Beispiele, welche zusammen mit der Arduino-IDE ausgeliefert werden unter: Datei -> Beispiele -> 01.Basics -> Blink
Dieses Blink-Programm läuft Standardmäßig auf jedem Arduino Board. Wenn man jetzt den UNO oder Nano über USB an eine Stromquelle anschließen würde, würde dieses Programm vom Werk aus darauf laufen – und eine LED auf dem Arduino-Board blinken.

Der Sketch dafür sieht dann so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
// the setup function runs once when you press reset or power the board
void setup() {
  // initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}
 
// the loop function runs over and over again forever
void loop() {
  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);              // wait for a second
  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);              // wait for a second
}

Wie oben erwähnt setzen wir in der Setup() Funktion die Einstellungen die vor dem eigentlichen Programmstart feststehen sollen. In diesem Fall wird der GPIO-Pin 13 als Ausgang definiert. An diesem Pin ist in den meisten Fällen eine LED auf dem Board angeschlossen.
In der loop() wird nun gesagt das am Pin 13 ein HIGH Signal angelegt werden soll.
Dies geschieht durch die Funktion digitalWrite() da der Pin 13 ein Digitaler Pin ist.
Da der Arduino mit einer Spannung von 5V arbeitet bedeutet das HIGH Signal hier, das diese 5V durchgereicht werden und die LED leuchtet.
Danach wird über das delay(1000) eine Wartezeit von 1000ms – also einer Sekunde – festgelegt, bevor das Programm weiter ausgeführt wird.
Dann wird ein LOW Signal, also 0V am Pin 13 ausgegeben – damit leuchtet die LED dann nicht mehr.
Und am ende wird wieder eine Sekunde gewartet.

Da uns eine Sekunde zu langsam ist, ändern wir die 1000ms hier einfach mal in 100ms ab.
Wenn wir nun den Arduino über ein USB-Kabel an den PC anschließen, können wir diesen in der Arduino-IDE auswählen:
Unter „Werkzeuge“ -> „Board, Prozessor, Port“: Arduino Nano, ATmega328 on COM3
Über den Button1 (erste Knopf oben links in der Arduino-IDE) kann man nun das Programm kompilieren und schauen ob man Fehler gemacht hat. Für dieses Beispiel werden aber keine Fehler gefunden.
Nun kann man über den Button2 (Rechts neben Button1 in der Arduino-IDE) das Programm zum Arduino geben.
In der IDE sollte dann in etwa so eine Ausgabe erscheinen:

1
2
3
Der Sketch verwendet 1.030 Bytes (3%) des Programmspeicherplatzes. Das Maximum sind 30.720 Bytes.
Globale Variablen verwenden 9 Bytes (0%) des dynamischen Speichers, 2.039 Bytes für lokale Variablen verbleiben. 
Das Maximum sind 2.048 Bytes.

Wenn dieser dann fertig ist, startet er neu und das neue Programm läuft. Was wir nun sehen ist das die LED nicht mehr jede Sekunde blinkt, sondern alle 100 Millisekunden.

Sehr schön! Da haben wir doch schon einiges für den Anfang geschafft 🙂

leave your comment

*

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.

Unterstütze den Frickelblog!