Difference between revisions of "Arduino Crash Kurs"

From www.wiki.ardumower.de
Jump to: navigation, search
(Die Seite wurde neu angelegt: „= 1. Dein erstes Programm = <blockquote style="background-color: lightgrey; border: solid thin grey;"> <pre> // Die setup-Funktion wird beim Programmstart ei…“)
 
 
(100 intermediate revisions by the same user not shown)
Line 1: Line 1:
 +
 +
[[Image:Arduino_led.png|150px]]
 +
[[Image:Arduino_relay.png|150px]]
 +
[[Image:Arduino_switch.png|150px]]
 +
[[Image:Arduino_potentiometer.jpg|150px]]
 +
[[Image:Arduino_delays.jpg|150px]]
 +
[[Image:Arduino_keyboard.png|150px]]
 +
[[Image:Arduino_bluetooth.jpg|150px]]
 +
 +
 +
So wie man für das Autofahren die Grundlagen bei der Fahrschule erlernt, kann man auch die Grundlagen der Programmierung für den Arduino erlernen wenn man ihn einsetzen will. Dieser Kurs kann in kurzer Zeit durchgearbeitet werden und man ist danach mit der Arduino-Programmierung vertraut.
 +
 
= 1. Dein erstes Programm =
 
= 1. Dein erstes Programm =
 +
 +
Wir steuern eine LED an. Wir verwenden dazu die interne Arduino LED (Pin 13), ihr braucht also nichts weiter anschliessen. Die Grafik dient nur als Beispiel falls ihr eine externe LED anschliessen wollt. Bitte nur mit Widerstand (300 Ohm) anschliessen, um den Strom zu begrenzen.
 +
 +
[[Image:Arduino_led.png|400px]]
 +
 +
Die setup-Funktion wird beim Programmstart einmal durchlaufen. Hier kann man Dinge durchführen, die nur einmal nach dem Arduino-Reset ausgeführt werden sollen. Die Loop-Funktion hingegen wird unendlich oft durchlaufen.
  
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<pre>
 
<pre>
 
  // Die setup-Funktion wird beim Programmstart einmal durchlaufen.
 
  // Die setup-Funktion wird beim Programmstart einmal durchlaufen.
  void setup() {
+
  void setup()  
  pinMode(13, OUTPUT); // Pin 13 soll als Ausgang konfiguriert werden
+
  {
 +
 
 
  }
 
  }
  
 
  // Die loop-Funktion wird unendlich oft wiederholt.
 
  // Die loop-Funktion wird unendlich oft wiederholt.
  void loop() {
+
  void loop()  
  digitalWrite(13, HIGH);    // Pin 13 soll auf HIGH ( 5 Volt ) gesetzt werden
+
{
  delay(1000);              // Warte 1000 Millisekunden (= 1 Sekunde)
+
 
  digitalWrite(13, LOW);    // Pin 13 soll auf LOW ( 0 Volt/Masse ) gesetzt werden
+
  delay(1000);              // Warte 1000 Millisekunden (= 1 Sekunde)
+
 
  }
 
  }
 
</pre>
 
</pre>
Line 19: Line 36:
  
  
= Expressions =
+
Aufgabe:
  
Everything that can be calculated is an expression. Expressions are used to compute things. We will use expressions later for variables or functions calls.
+
1. Übertrage obige Zeilen in die Arduino IDE.
  
Examples for expressions:
+
2. Baue folgende Zeile in die setup-Funktion ein:
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
  pinMode(13, OUTPUT)// Pin 13 soll als Ausgang konfiguriert werden (für LED ansteuern)
<pre>
+
  13               => can be computed to 13 (it's simple right?)
+
2 * 13          => can be computed to 26
+
42 - 9 * 100    => can be computed as everything is known to compute it
+
a + b - c + 20  => can be computed if a, b and c are known
+
</pre>
+
</blockquote>
+
  
= Variables =
+
3. Baue folgende Zeilen in die loop-Funktion ein:
  
A memory variable can contain a value (integer number, floating number, text character etc.). It is useful to use variables instead of repeating hard wired numbers. Here the same example, this time using a variable for the LED pin:
+
  digitalWrite(13, HIGH);    // Pin 13 soll auf HIGH ( 5 Volt ) gesetzt werden
 +
  delay(1000);              // Warte 1000 Millisekunden (= 1 Sekunde)
 +
  digitalWrite(13, LOW);    // Pin 13 soll auf LOW ( 0 Volt/Masse ) gesetzt werden
 +
  delay(1000);              // Warte 1000 Millisekunden (= 1 Sekunde)
 +
 
 +
4. Starte Dein Programm über die Arduino IDE und schaue ob die Arduino LED blinkt.
 +
 
 +
= 1. Lösung =
  
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<pre>
 
<pre>
  // declare an integer variable named 'pinLED' and assign it the value 13
+
  // Die setup-Funktion wird beim Programmstart einmal durchlaufen.
int pinLED = 13;      // this is a comment
+
  void setup()  
 
+
{
  void setup() {
+
   pinMode(13, OUTPUT); // Pin 13 soll als Ausgang konfiguriert werden
   pinMode(pinLED, OUTPUT);   // here, we use the variable named 'pinLED' instead of the hard-wired number
+
 
  }
 
  }
  
  void loop() {
+
// Die loop-Funktion wird unendlich oft wiederholt.
   digitalWrite(pinLED, HIGH);    // here, we use again the variable 'pinLED'
+
  void loop()  
   delay(1000);            
+
{
   digitalWrite(pinLED, LOW);    // here, we use again the variable 'pinLED'
+
   digitalWrite(13, HIGH);    // Pin 13 soll auf HIGH ( 5 Volt ) gesetzt werden
   delay(1000);            
+
   delay(1000);               // Warte 1000 Millisekunden (= 1 Sekunde)
 +
   digitalWrite(13, LOW);    // Pin 13 soll auf LOW ( 0 Volt/Masse ) gesetzt werden
 +
   delay(1000);               // Warte 1000 Millisekunden (= 1 Sekunde)
 
  }
 
  }
 
</pre>
 
</pre>
 
</blockquote>
 
</blockquote>
  
Try it out! Variables can be integer number, floating numbers, logical (TRUE/FALSE), and text characters:
+
= 2. Dein erstes Programm mit Variablen und serieller Konsole =
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
Aufgabe:  
<pre>
+
int someIntegerNumber = 42;
+
boolean someLogical = TRUE;
+
float someFloatingNumber = 3.1419;
+
char someCharacters[] = "Hello World";
+
</pre>
+
</blockquote>
+
  
A variable's contents can be re-assigned at any time in the program:
+
1. Ersetze die Pin-Nummer "13" durch eine Variable welche Du außerhalb von Funktionen definierst:
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
  int pinLED = 13; // die Variable namens "pinLED" soll den Wert 13 bekommen
<pre>
+
  int pinLED = 13;   // declare variable named pinLED and initialize it with value 13
+
pinLED = 12;      // assign pinLED a new value (12)
+
</pre>
+
</blockquote>
+
  
You can even use calculations/expressions:
+
2. Ersetze nun überall dort die "13" durch "pinLED" wo der LED-Pin benutzt wird.
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
3. Teste Dein Programm einmal.
<pre>
+
int A = 4;
+
int B = A * 42 + 15;
+
</pre>
+
</blockquote>
+
  
 +
4. Baue folgende Zeilen in die setup-Funktion ein:
  
You may wonder what the values 'HIGH' and 'LOW' in the above code example are. These are integer constants that the Arduino library already did define for you (HIGH = 1, LOW = 0). Using variables and constants makes code more human-readable.
+
  Serial.begin(115200);    // serielle Konsole für 115200 Baud konfigurieren
 +
  Serial.println("START");  // Text auf serielle Konsole ausgeben
  
= Functions =
+
5. Baue folgende Zeilen jeweils an geeigneter Stelle in die loop-Funktion ein:
  
We did use three pre-defined functions already in above code which are already defined by the Arduino library:
+
  Serial.println("LED EIN");    // Text auf serielle Konsole ausgeben
 +
  Serial.println("LED AUS");    // Text auf serielle Konsole ausgeben
 +
 
 +
= 2. Lösung =
  
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<pre>
 
<pre>
  pinMode
+
  int pinLED = 13; // die Variable namens "pinLED" soll den Wert 13 bekommen
  digitalWrite
+
delay
+
</pre>
+
</blockquote>
+
  
Additionally, we already defined ourselves two functions in above code: 'setup' and 'loop'. Functions group commands into blocks. These blocks are then called by the name of the function. A function can also have input parameters, and one output parameter.
+
// Die setup-Funktion wird beim Programmstart einmal durchlaufen.
 +
void setup()
 +
{
 +
  pinMode(pinLED, OUTPUT);  // PinLED soll als Ausgang konfiguriert werden
 +
  Serial.begin(115200);    // serielle Konsole für 115200 Baud konfigurieren
 +
  Serial.println("START");  // Text auf serielle Konsole ausgeben
 +
}
  
Example:
+
  // Die loop-Funktion wird unendlich oft wiederholt.
 
+
  void loop()  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
{
<pre>
+
   digitalWrite(pinLED, HIGH);    // PinLED soll auf HIGH ( 5 Volt ) gesetzt werden
  // Declares a function named 'writeAndWait' to set LED to a given value (HIGH/LOW) and wait
+
  Serial.println("LED EIN");    // Text auf serielle Konsole ausgeben
  void writeAndWait(int value){
+
  delay(1000);                  // Warte 1000 Millisekunden (= 1 Sekunde)
   digitalWrite(pinLED, value);    // here, we use the parameter 'value' instead of a fixed HIGH/LOW value
+
  digitalWrite(pinLED, LOW);    // PinLED soll auf LOW ( 0 Volt/Masse ) gesetzt werden
   delay(1000);              
+
  Serial.println("LED AUS");    // Text auf serielle Konsole ausgeben
 +
   delay(1000);                   // Warte 1000 Millisekunden (= 1 Sekunde)
 
  }
 
  }
 
</pre>
 
</pre>
 
</blockquote>
 
</blockquote>
  
Now we can use that new function to make the main loop more readable:
+
= 3. Ein Relais ansteuern =
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
Genauso wie ihr die LED angsteuert habt, könnt ihr auch ein Relais ansteuern.
<pre>
+
void loop() {
+
  writeAndWait(HIGH);  // call function with 'HIGH' (for parameter 'value')
+
  writeAndWait(LOW);  // call function with 'LOW' (for parameter 'value')
+
}
+
</pre>
+
</blockquote>
+
  
After each statement (variable assignment, function call etc.) we make a semicolon. The semicolon divides the current statement and the next statement. Try it out!
+
[[Image:Arduino_relay.png|500px]]
  
 +
Aufgabe: schaltet anstelle der LED das Relais ein und aus
  
Optionally, a function can return a value. In this example, the function named 'addSomething' will compute the sum of its input parameters 'a' and 'b' and return that computed sum.
+
= 4. Ein Taster =
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
Wir schließen einen Taster an den Arduino. Die LED soll nur dann auslösen wenn der Taster gedrückt wird.
<pre>
+
int addSomething(int a, int b){
+
  return a + b;
+
}
+
</pre>
+
</blockquote>
+
  
Now you use your new function to compute the sum of any integer values:
+
[[Image:Arduino_switch.png|400px]]
 +
[[Image:Arduino_pullup.png|600px]]
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<pre>
 
int c = addSomething( 4, 5 );
 
</pre>
 
</blockquote>
 
  
= Serial console output and text =
+
Aufgabe:
To get feedback from your Arduino, you may want to use the serial console. Let's see a simple example. Run this program and open your Arduino IDE serial console (CTRL+SHIFT+M) at 19200 baud and look if it returns the text.
+
1. Schliesse den Taster an Pin 2 an und definiere den Pin:
  
 +
int pinSwitch = 2;  // Pin für Taster definieren
 +
 +
2. Baue folgende Zeile in die setup-Funktion ein:
 +
 +
  pinMode(pinSwitch, INPUT_PULLUP); // Taster soll als Eingang (mit Pull-Up) konfiguriert werden
 +
 +
3. Baue folgende Zeilen in die loop-Funktion ein:
 +
 +
  int zustand = !digitalRead(pinSwitch); // Taster in Variable "zustand" einlesen und invertieren (aus LOW wird HIGH und umgekehrt)
 +
 +
  Serial.print("Taster Zustand: ");
 +
  Serial.println( zustand );
 +
 +
  digitalWrite( pinLED, zustand );      // LED passend ansteuern
 +
  delay(1000);
 +
 +
= 4. Lösung =
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<blockquote style="background-color: lightgrey; border: solid thin grey;">
 
<pre>
 
<pre>
  void setup(){
+
int pinSwitch = 2;  // Pin für Taster
   Serial.begin(19200); // set the baud rate to use
+
int pinLED = 13;    // Pin für LED
 +
 
 +
  void setup()
 +
{
 +
  pinMode(pinSwitch, INPUT_PULLUP); // Taster soll als Eingang (mit Pull-Up) konfiguriert werden
 +
  pinMode(pinLED, OUTPUT);          // LED soll als Ausgang konfiguriert werden
 +
   Serial.begin(115200);             // serielle Konsole mit 115200 Baud konfigurieren
 
  }
 
  }
  
  void loop(){
+
  void loop()
   Serial.println("Hello world"); // output the text to Arduino serial console
+
{
 +
  int zustand = !digitalRead(pinSwitch); // Taster in Variable einlesen und invertieren (aus LOW wird HIGH und umgekehrt)
 +
 
 +
   Serial.print("Taster ist ");  
 +
  Serial.println( zustand );
 +
 
 +
  digitalWrite( pinLED, zustand );      // LED passend ansteuern
 
   delay(1000);
 
   delay(1000);
 
  }
 
  }
Line 162: Line 184:
 
</blockquote>
 
</blockquote>
  
= For-loops and blocks =
+
= 4. Abfragen =
To repeat things, use for-loops. This example will repeat outputting the text by using a variable ('counter') that counts from 0 to 3. Each time the loop is executed, the variable 'counter' will increase by one:
+
  
Hello 0
+
Unser Programm soll zwei unterschiedliche Zweige bekommen. Wir lösen dies durch eine Abfrage.
Hello 1
+
Hello 2
+
Hello 3
+
... then the main loop restarts...
+
  
The example uses a block indicated by '{ ... }'. Everything that is inside this block is run each time the for-loop increases.
+
[[Image:Arduino_if_else.png]]
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
Aufgabe:
<pre>
+
1. Baue folgende Abfrage in die loop-Funktion ein:
void loop(){ 
+
 
   for (int counter=0; counter < 4; counter++)
+
   if (zustand == HIGH)
 
   {
 
   {
     Serial.print("Hello ");
+
     Serial.println( "Der Schalter ist AUS" );
     Serial.println(counter);
+
  }
 +
  else
 +
  {
 +
     Serial.println( "Der Schalter ist EIN" );
 
   }
 
   }
  delay(1000);
 
}
 
</pre>
 
</blockquote>
 
  
Try it out!
+
= 6. Schleifen =
  
= Digital input =
+
Mit Schleifen können wir Befehle wiederholen.  
Let's read the ouside world - we'll read the state of digital pin 5 in this example. We use the Arduino internal pull-up resistor (so pin 5 is HIGH when the switch is open). Simply connect pin 5 to GND to make the switch going LOW.
+
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
[[Image:Arduino_loops.jpg]]
<pre>
+
int pinSwitch = 5; // connect this pin to GND to activate the switch
+
int pinLED = 13;  // we use the Arduino onboard LED
+
  
void setup(){
+
Aufgabe:
  // configure the switch pin to use the Arduino internal pull-up resistor
+
  pinMode(pinSwitch, INPUT_PULLUP);
+
  pinMode(pinLED, OUTPUT);
+
  Serial.begin(19200); 
+
}
+
  
void loop(){ 
+
1. Baue folgende Schleife in die loop-Funktion ein:
  // read the value of the switch pin - it is '1' when HIGH, and '0' when LOW.
+
  int value = digitalRead( pinSwitch );
+
  Serial.print("The switch is ");
+
  Serial.println( value );
+
  // write the value to the LED pin - it will be HIGH when writing a '1', and LOW when writing a '0'.
+
  digitalWrite( pinLED, value );
+
  delay(1000);
+
}
+
</pre>
+
</blockquote>
+
  
Try it out!
+
  for (int zeit=0; zeit < 4; zeit++)
 +
  {
 +
    Serial.print("Warte ");
 +
    Serial.println(zeit);
 +
    delay(1000);
 +
  }
  
= If-clauses =
+
= 7. Potentiometer =
For running code based on conditions, use if-clauses. If the condition for the if-clause evaluates to logical-TRUE, the first block is called, otherwise the else block.
+
  
Example:
+
Ein Potentiometer arbeitet analog. Wir nutzen den Analog-zu-digital Konverter (ADC), um aus analogen Eingangssignalen digitale zu machen.
  
<blockquote style="background-color: lightgrey; border: solid thin grey;">
+
[[Image:Arduino_potentiometer.jpg]]
<pre>
+
 
void loop(){
+
Aufgabe:
  int value = digitalRead ( pinSwitch );
+
 
  if (value == HIGH){
+
1. Schliesse das Poti an den Arduino Pin A0 an.
    Serial.println( "The switch is HIGH" );
+
  Pin 1: Masse
  }  
+
  Pin 2: A0
  else {
+
  Pin 3: +5V
    Serial.println( "The switch is LOW" );  
+
 
   }
+
  [[Image:Arduino_poti_circuit.png]]
  delay(1000);
+
 
}
+
 
</pre>
+
2. Konfiguriere den Potentiometer-Pin als Eingang:
</blockquote>
+
 
 +
  int pinPoti = A0;
 +
  pinMode(pinA0, INPUT);
 +
 
 +
 
 +
3. Lese das Potentiometer in eine Variable ein:
 +
 
 +
  int zustand = analogRead( pinPoti );
 +
 
 +
  Serial.println(zustand);
 +
 
 +
= 8. Zeit und Verzögerungen =
 +
 
 +
Eine LED soll max. 3 Sekunden leuchten und zusätzlich über einen Taster sofort abgestellt werden können.
 +
 
 +
Die abgelaufene Zeit seit Programmstart kann mit der Funktion "millis" abgefragt werden. Sie liefert Millisekunden zurück.
 +
 
 +
[[Image:Arduino_delays.jpg]]
 +
 
 +
Aufgabe:
 +
 
 +
1. Baue folgende Zeilen in Dein Programm ein:
 +
 
 +
    if (millis() >= 3000) digitalWrite(pinLED, LOW);
 +
 
 +
    if (digitalRead(pinSwitch)==LOW) digitalWrite(pinLED, LOW);
 +
 
 +
2. Diesmal soll die LED nur beim loslassen zeitverzögert mit 3 Sekunden wieder einschalten. Tipp: benutze eine Variable um die Zeit der LED-Einschaltung zu speichern.
 +
 
 +
= 8. Lösung =
 +
 
 +
  unsigned long zeit; // Variable soll Zeit für die LED-Einschaltung speichern
 +
 
 +
  if (digitalRead(pinSwitch)==LOW)
 +
  {
 +
    // Taster gedrückt
 +
    zeit = millis() + 3000; // Zeit für LED-Einschalten berechnen und in Variable speichern
 +
    digitalWrite(pinLED, LOW);
 +
  }
 +
  else {
 +
    // Taster losgelassen
 +
    if (millis() >= zeit)
 +
    {
 +
      // Zeit zum Einschalten erreicht
 +
      digitalWrite(pinLED, HIGH);
 +
    }
 +
  }
 +
 
 +
= 9. serielle Tastatur =
 +
 
 +
Eine Taste (Taste 'L') auf der PC Tastatur soll die Arduino LED ein- und ausschalten.
 +
 
 +
[[Image:Arduino_keyboard.png|200px]]
 +
 
 +
Aufgabe:
 +
 
 +
1. Baue folgende Zeilen in Dein Programm ein:
 +
 
 +
  boolean zustand = false; // Zustandsvariable für unsere LED
 +
 
 +
  if (Serial.available())
 +
  {  
 +
    char key = Serial.read();
 +
    Serial.print("Du hast gedrückt: ");
 +
    Serial.println(key); 
 +
    if (key == 'l')
 +
    {
 +
      zustand = !zustand;  // Zustand invertieren (aus LOW wird HIGH und aus HIGH wird LOW)
 +
      digitalWrite( pinLED, zustand );
 +
    }
 +
  }
 +
 
 +
2. Erweitere Dein Programm um die Abfrage weiterer Tasten:
 +
 
 +
  switch (key){
 +
    case 'l': zustand = !zustand;
 +
              digitalWrite( pinLED, zustand );
 +
              break; 
 +
 
 +
    case 't': Serial.printl("text");
 +
              break;
 +
  }
 +
 
 +
= 10. Bluetooth / pfodApp =
 +
 
 +
Wir wollen ein Menü (mit 2 Menüpunkten) programmieren welches man per Bluetooth (pfodApp) bedienen kann.
 +
 
 +
  [Menu]
 +
Zeit: 3945
 +
Punkt1
 +
Punkt2
 +
 
 +
[[Image:Arduino_bluetooth.jpg|800px]]
 +
[[Image:Arduino_string.png|400px]]
 +
 
 +
Aufgabe:
 +
 
 +
1. Schliesse das HC-05-Modul wie gezeigt an den Arduino Mega an (ohne State- und Key-Leitungen).
 +
 
 +
2. Lade folgendes Programm in den Arduino:
 +
 
 +
  String cmd; // Diese Zeichenkette soll später das vollständige Menü-Kommando enthalten
 +
 
 +
  void setup()
 +
  {
 +
    Serial.begin(115200);  // serielle Verbindung zum PC konfigurieren
 +
    Serial1.begin(19200);  // serielle Verbindung zum HC-05 Modul konfigurieren
 +
  }
 +
 
 +
  // Das Menü zum HC-05 Modul schicken
 +
  void sendMainMenu(boolean update)
 +
  {
 +
    if (update) Serial1.print("{:");  
 +
    else {
 +
      Serial1.print("{.Menu`1000");    
 +
    }
 +
    Serial1.print("|mn0~Zeit ");
 +
    Serial1.print(millis());
 +
    Serial1.print("|mn1~Punkt1 ");
 +
    Serial1.print("|mn2~Punkt2 ");
 +
    Serial1.println("}");
 +
  }
 +
 
 +
  // Auf Menüauswahl reagieren
 +
  void processMainMenu(String cmd)
 +
  {     
 +
    if (cmd == "mn1")
 +
    {
 +
      Serial.println("Menüpunkt1 gewählt");
 +
    }
 +
    else if (cmd == "mn2")
 +
    {
 +
      Serial.println("Menüpunkt2 gewählt");
 +
    }
 +
    sendMainMenu(true);
 +
  }
  
Conditions can be more complex of course:
+
  void loop()
 +
  {   
 +
    if (Serial1.available())
 +
    {
 +
      char ch = Serial1.read(); // nächstes Zeichen vom HC-05 Modul einlesen     
 +
      if (ch == '{')
 +
      {
 +
        cmd = "";  // Start-Kommando
 +
      }
 +
      else if (ch == '}')      // Stop-Kommando
 +
      {
 +
        // Menükommando ist vollständig
 +
        Serial.print("pfod cmd=");
 +
        Serial.println(cmd); 
 +
        if (cmd == ".") sendMainMenu(false);     
 +
        else if (cmd.startsWith("mn")) processMainMenu(cmd);
 +
          else Serial1.println("{}");       
 +
        cmd = "";
 +
      }
 +
      else cmd += ch;                // Zeichenkette vervollständigen
 +
    }
 +
  }
  
if (numberX > 5)... // variable 'numberX' must be larger than 5
+
3. Ergänze Menüpunkt 1 um das Ein- und Ausschalten einer LED (Pin 13).
if (numberX > numberY) ... // variable 'numberX' must be larger than variable 'numberY'
+
if (numberX == numberY) ... // 'numberX ' must be equal 'numberY'
+
if (numberX < numberY) ... // 'numberX' must be smaller than 'numberY'
+
  
Also you can combine multiple conditions:
+
4. Ergänze Menüpunkt 1 um die Anzeige des aktuellen LED Zustandes (ein/aus).
  
if ( (number > 5) && (number < 10) )... // logical AND: both conditions must be TRUE
+
= 10. Lösung =
if ( (number < 5) || (number > 10) )... // logical OR: only one condition must be TRUE
+
  
= What you have learned =
+
  boolean zustand = false;  // Variable für LED-Zustand
*Variables can contain numbers (integer, float) or text (characters) and are placeholders for them.
+
*Functions can containe blocks of code and are placeholders for the blocks.
+
  
 +
    zustand = !zustand;            // Zustand invertieren
 +
    digitalWrite(pinLED, zustand); // LED schalten
 +
    Serial1.print("|mn1~LED ");    // Zustand im Menüpunkt anzeigen
 +
    if (zustand == LOW)           
 +
      Serial1.print("AUS");
 +
    else
 +
      Serial1.print("EIN");
  
= Further links =
+
= Arduino Starter Kit =
 +
http://wiki.epalsite.com/index.php?title=Starter_Kit_for_Arduino

Latest revision as of 04:41, 30 May 2017

Arduino led.png Arduino relay.png Arduino switch.png Arduino potentiometer.jpg Arduino delays.jpg Arduino keyboard.png Arduino bluetooth.jpg


So wie man für das Autofahren die Grundlagen bei der Fahrschule erlernt, kann man auch die Grundlagen der Programmierung für den Arduino erlernen wenn man ihn einsetzen will. Dieser Kurs kann in kurzer Zeit durchgearbeitet werden und man ist danach mit der Arduino-Programmierung vertraut.

1. Dein erstes Programm

Wir steuern eine LED an. Wir verwenden dazu die interne Arduino LED (Pin 13), ihr braucht also nichts weiter anschliessen. Die Grafik dient nur als Beispiel falls ihr eine externe LED anschliessen wollt. Bitte nur mit Widerstand (300 Ohm) anschliessen, um den Strom zu begrenzen.

Arduino led.png

Die setup-Funktion wird beim Programmstart einmal durchlaufen. Hier kann man Dinge durchführen, die nur einmal nach dem Arduino-Reset ausgeführt werden sollen. Die Loop-Funktion hingegen wird unendlich oft durchlaufen.

 // Die setup-Funktion wird beim Programmstart einmal durchlaufen.
 void setup() 
 {

 }

 // Die loop-Funktion wird unendlich oft wiederholt.
 void loop() 
 {

 }


Aufgabe:

1. Übertrage obige Zeilen in die Arduino IDE.

2. Baue folgende Zeile in die setup-Funktion ein:

  pinMode(13, OUTPUT);  // Pin 13 soll als Ausgang konfiguriert werden (für LED ansteuern)

3. Baue folgende Zeilen in die loop-Funktion ein:

  digitalWrite(13, HIGH);    // Pin 13 soll auf HIGH ( 5 Volt ) gesetzt werden
  delay(1000);               // Warte 1000 Millisekunden (= 1 Sekunde)
  digitalWrite(13, LOW);     // Pin 13 soll auf LOW ( 0 Volt/Masse ) gesetzt werden
  delay(1000);               // Warte 1000 Millisekunden (= 1 Sekunde)

4. Starte Dein Programm über die Arduino IDE und schaue ob die Arduino LED blinkt.

1. Lösung

 // Die setup-Funktion wird beim Programmstart einmal durchlaufen.
 void setup() 
 {
   pinMode(13, OUTPUT);  // Pin 13 soll als Ausgang konfiguriert werden
 }

 // Die loop-Funktion wird unendlich oft wiederholt.
 void loop() 
 {
   digitalWrite(13, HIGH);    // Pin 13 soll auf HIGH ( 5 Volt ) gesetzt werden
   delay(1000);               // Warte 1000 Millisekunden (= 1 Sekunde)
   digitalWrite(13, LOW);     // Pin 13 soll auf LOW ( 0 Volt/Masse ) gesetzt werden
   delay(1000);               // Warte 1000 Millisekunden (= 1 Sekunde)
 }

2. Dein erstes Programm mit Variablen und serieller Konsole

Aufgabe:

1. Ersetze die Pin-Nummer "13" durch eine Variable welche Du außerhalb von Funktionen definierst:

int pinLED = 13;  // die Variable namens "pinLED" soll den Wert 13 bekommen

2. Ersetze nun überall dort die "13" durch "pinLED" wo der LED-Pin benutzt wird.

3. Teste Dein Programm einmal.

4. Baue folgende Zeilen in die setup-Funktion ein:

  Serial.begin(115200);     // serielle Konsole für 115200 Baud konfigurieren
  Serial.println("START");  // Text auf serielle Konsole ausgeben

5. Baue folgende Zeilen jeweils an geeigneter Stelle in die loop-Funktion ein:

  Serial.println("LED EIN");     // Text auf serielle Konsole ausgeben
  Serial.println("LED AUS");     // Text auf serielle Konsole ausgeben

2. Lösung

 int pinLED = 13;  // die Variable namens "pinLED" soll den Wert 13 bekommen

 // Die setup-Funktion wird beim Programmstart einmal durchlaufen.
 void setup() 
 {
   pinMode(pinLED, OUTPUT);  // PinLED soll als Ausgang konfiguriert werden
   Serial.begin(115200);     // serielle Konsole für 115200 Baud konfigurieren
   Serial.println("START");  // Text auf serielle Konsole ausgeben
 }

 // Die loop-Funktion wird unendlich oft wiederholt.
 void loop() 
 {
   digitalWrite(pinLED, HIGH);    // PinLED soll auf HIGH ( 5 Volt ) gesetzt werden
   Serial.println("LED EIN");     // Text auf serielle Konsole ausgeben
   delay(1000);                   // Warte 1000 Millisekunden (= 1 Sekunde)
   digitalWrite(pinLED, LOW);     // PinLED soll auf LOW ( 0 Volt/Masse ) gesetzt werden
   Serial.println("LED AUS");     // Text auf serielle Konsole ausgeben
   delay(1000);                   // Warte 1000 Millisekunden (= 1 Sekunde)
 }

3. Ein Relais ansteuern

Genauso wie ihr die LED angsteuert habt, könnt ihr auch ein Relais ansteuern.

Arduino relay.png

Aufgabe: schaltet anstelle der LED das Relais ein und aus

4. Ein Taster

Wir schließen einen Taster an den Arduino. Die LED soll nur dann auslösen wenn der Taster gedrückt wird.

Arduino switch.png Arduino pullup.png


Aufgabe: 1. Schliesse den Taster an Pin 2 an und definiere den Pin:

int pinSwitch = 2;  // Pin für Taster definieren

2. Baue folgende Zeile in die setup-Funktion ein:

  pinMode(pinSwitch, INPUT_PULLUP); // Taster soll als Eingang (mit Pull-Up) konfiguriert werden

3. Baue folgende Zeilen in die loop-Funktion ein:

  int zustand = !digitalRead(pinSwitch); // Taster in Variable "zustand" einlesen und invertieren (aus LOW wird HIGH und umgekehrt)
  Serial.print("Taster Zustand: "); 
  Serial.println( zustand );
  digitalWrite( pinLED, zustand );      // LED passend ansteuern
  delay(1000);

4. Lösung

 int pinSwitch = 2;  // Pin für Taster
 int pinLED = 13;    // Pin für LED

 void setup()
 {
   pinMode(pinSwitch, INPUT_PULLUP); // Taster soll als Eingang (mit Pull-Up) konfiguriert werden
   pinMode(pinLED, OUTPUT);          // LED soll als Ausgang konfiguriert werden
   Serial.begin(115200);             // serielle Konsole mit 115200 Baud konfigurieren
 }

 void loop()
 {  
   int zustand = !digitalRead(pinSwitch); // Taster in Variable einlesen und invertieren (aus LOW wird HIGH und umgekehrt)

   Serial.print("Taster ist "); 
   Serial.println( zustand );

   digitalWrite( pinLED, zustand );      // LED passend ansteuern
   delay(1000);
 }

4. Abfragen

Unser Programm soll zwei unterschiedliche Zweige bekommen. Wir lösen dies durch eine Abfrage.

Arduino if else.png

Aufgabe: 1. Baue folgende Abfrage in die loop-Funktion ein:

  if (zustand == HIGH)
  {
    Serial.println( "Der Schalter ist AUS" );
  }
  else
  {
    Serial.println( "Der Schalter ist EIN" );
  }

6. Schleifen

Mit Schleifen können wir Befehle wiederholen.

Arduino loops.jpg

Aufgabe:

1. Baue folgende Schleife in die loop-Funktion ein:

  for (int zeit=0; zeit < 4; zeit++)
  {
    Serial.print("Warte ");
    Serial.println(zeit);
    delay(1000);
  }

7. Potentiometer

Ein Potentiometer arbeitet analog. Wir nutzen den Analog-zu-digital Konverter (ADC), um aus analogen Eingangssignalen digitale zu machen.

Arduino potentiometer.jpg

Aufgabe:

1. Schliesse das Poti an den Arduino Pin A0 an.

 Pin 1: Masse
 Pin 2: A0
 Pin 3: +5V
 Arduino poti circuit.png


2. Konfiguriere den Potentiometer-Pin als Eingang:

 int pinPoti = A0;
 pinMode(pinA0, INPUT);


3. Lese das Potentiometer in eine Variable ein:

 int zustand = analogRead( pinPoti );
 Serial.println(zustand);

8. Zeit und Verzögerungen

Eine LED soll max. 3 Sekunden leuchten und zusätzlich über einen Taster sofort abgestellt werden können.

Die abgelaufene Zeit seit Programmstart kann mit der Funktion "millis" abgefragt werden. Sie liefert Millisekunden zurück.

Arduino delays.jpg

Aufgabe:

1. Baue folgende Zeilen in Dein Programm ein:

   if (millis() >= 3000) digitalWrite(pinLED, LOW);
   if (digitalRead(pinSwitch)==LOW) digitalWrite(pinLED, LOW);

2. Diesmal soll die LED nur beim loslassen zeitverzögert mit 3 Sekunden wieder einschalten. Tipp: benutze eine Variable um die Zeit der LED-Einschaltung zu speichern.

8. Lösung

 unsigned long zeit; // Variable soll Zeit für die LED-Einschaltung speichern
 if (digitalRead(pinSwitch)==LOW) 
 {
   // Taster gedrückt
   zeit = millis() + 3000; // Zeit für LED-Einschalten berechnen und in Variable speichern
   digitalWrite(pinLED, LOW);
 } 
 else {
   // Taster losgelassen
   if (millis() >= zeit) 
   {
     // Zeit zum Einschalten erreicht
     digitalWrite(pinLED, HIGH);
   }
 }

9. serielle Tastatur

Eine Taste (Taste 'L') auf der PC Tastatur soll die Arduino LED ein- und ausschalten.

Arduino keyboard.png

Aufgabe:

1. Baue folgende Zeilen in Dein Programm ein:

 boolean zustand = false; // Zustandsvariable für unsere LED
 if (Serial.available())
 { 
   char key = Serial.read();
   Serial.print("Du hast gedrückt: ");
   Serial.println(key);  
   if (key == 'l')
   {
     zustand = !zustand;  // Zustand invertieren (aus LOW wird HIGH und aus HIGH wird LOW)
     digitalWrite( pinLED, zustand );
   }
 }

2. Erweitere Dein Programm um die Abfrage weiterer Tasten:

 switch (key){
   case 'l': zustand = !zustand;
             digitalWrite( pinLED, zustand );
             break;  
   case 't': Serial.printl("text");
             break;
 }

10. Bluetooth / pfodApp

Wir wollen ein Menü (mit 2 Menüpunkten) programmieren welches man per Bluetooth (pfodApp) bedienen kann.

[Menu]
Zeit: 3945
Punkt1
Punkt2

Arduino bluetooth.jpg Arduino string.png

Aufgabe:

1. Schliesse das HC-05-Modul wie gezeigt an den Arduino Mega an (ohne State- und Key-Leitungen).

2. Lade folgendes Programm in den Arduino:

 String cmd; // Diese Zeichenkette soll später das vollständige Menü-Kommando enthalten
 void setup()
 {
   Serial.begin(115200);  // serielle Verbindung zum PC konfigurieren
   Serial1.begin(19200);  // serielle Verbindung zum HC-05 Modul konfigurieren
 }
 // Das Menü zum HC-05 Modul schicken
 void sendMainMenu(boolean update)
 {
   if (update) Serial1.print("{:"); 
   else {
     Serial1.print("{.Menu`1000");    
   }
   Serial1.print("|mn0~Zeit ");
   Serial1.print(millis()); 
   Serial1.print("|mn1~Punkt1 ");
   Serial1.print("|mn2~Punkt2 ");
   Serial1.println("}");
 }
 // Auf Menüauswahl reagieren
 void processMainMenu(String cmd)
 {      
   if (cmd == "mn1") 
   {
     Serial.println("Menüpunkt1 gewählt");
   }
   else if (cmd == "mn2") 
   {
     Serial.println("Menüpunkt2 gewählt");
   }
   sendMainMenu(true);
 }
 void loop()
 {    
   if (Serial1.available())
   {
     char ch = Serial1.read(); // nächstes Zeichen vom HC-05 Modul einlesen      
     if (ch == '{') 
     {
       cmd = "";  // Start-Kommando
     }
     else if (ch == '}')       // Stop-Kommando
     {
       // Menükommando ist vollständig
       Serial.print("pfod cmd=");
       Serial.println(cmd);  
       if (cmd == ".") sendMainMenu(false);      
       else if (cmd.startsWith("mn")) processMainMenu(cmd);		
         else Serial1.println("{}");        
       cmd = "";
     } 
     else cmd += ch;                // Zeichenkette vervollständigen
   }
 }

3. Ergänze Menüpunkt 1 um das Ein- und Ausschalten einer LED (Pin 13).

4. Ergänze Menüpunkt 1 um die Anzeige des aktuellen LED Zustandes (ein/aus).

10. Lösung

 boolean zustand = false;   // Variable für LED-Zustand
   zustand = !zustand;            // Zustand invertieren
   digitalWrite(pinLED, zustand); // LED schalten
   Serial1.print("|mn1~LED ");    // Zustand im Menüpunkt anzeigen
   if (zustand == LOW)            
     Serial1.print("AUS");
   else
     Serial1.print("EIN");

Arduino Starter Kit

http://wiki.epalsite.com/index.php?title=Starter_Kit_for_Arduino