Arduino - bscw.sfz-bw.debscw.sfz-bw.de/pub/bscw.cgi/S5b4d6898/d329697/Arduino-Skript.pdf · ARDUINO...

ARDUINO Von der blinkenden LED bis zum autonomen Roboter

EXPOSEE

Wir tauchen Schritt für Schritt in die faszinierende Welt des Arduinos ein. Zahlreiche Experimente, Arbeitsblätter und Lösungsvorschläge unterstützen die Einführung. Rudolf und Marita Lehn, Margret Tomczyk

Lehrerfortbildung im SFZ Bad Saulgau

Schülerforschungszentrum Südwürttemberg Klösterle 1a, 88348 Bad Saulgau

15.07.18 2

Inhaltsverzeichnis

1 Arduino ............................................................................................................................. 4

2 Blinkende LED ................................................................................................................... 5

2.1 AB 1: Blinkende LED ............................................................................................................ 7

2.2 ABL 1: Blinkende LED - Lösung ............................................................................................ 8

3 Messen mit dem Multimeter ............................................................................................. 9

4 Lauflicht mit LEDs ............................................................................................................ 10

4.1 AB 2a: Lauflicht.................................................................................................................. 11

4.2 ABL 2a: Lauflicht - Lösung ................................................................................................. 12

4.3 AB 2b: Lauflicht – Programm mit „for-Schleife“ ............................................................... 13

4.4 AB 3: Ampelsteuerung ...................................................................................................... 14

4.5 ABL 3: Ampelsteuerung - Lösung ...................................................................................... 15

4.6 AB 4: Spannungen in der Reihenschaltung ....................................................................... 16

4.7 ABL 4: Spannungen in der Reihenschaltung - Lösung ...................................................... 18

5 Analog-Digital-Wandler im Arduino ................................................................................. 20

5.1 AB 5: Ausgabe der AD-Werte ............................................................................................ 21

5.2 ABL 5: Ausgabe der AD-Werte - Lösung ............................................................................ 23

5.3 AB 6: LED bei Dunkelheit einschalten ............................................................................... 24

5.4 ABL 6: LED bei Dunkelheit einschalten - Lösung ............................................................... 26

6 Bewegungsmelder ........................................................................................................... 28

6.1 AB 7: Alarmanlage ............................................................................................................. 29

6.2 ABL 7: Alarmanlage - Lösung ............................................................................................. 31

7 Entfernungsmessung mit Ultraschall ................................................................................ 33

7.1 AB 8: Entfernungsmesser mit Ultraschall ......................................................................... 35

7.2 ABL 8: Entfernungsmesser mit Ultraschall - Lösung ......................................................... 37

8 Steuerung eines Gleichstrommotors ................................................................................ 39

8.1 AB 9: Gleichstrommotor mit Richtungswechsel ............................................................... 40

8.2 ABL 9: Gleichstrommotor mit Richtungswechsel - Lösung ............................................... 42

8.3 Regulierung der Geschwindigkeit des Gleichstrommotors .............................................. 43

8.4 AB 10: Geschwindigkeitsregelung ..................................................................................... 44

8.5 ABL 10: Geschwindigkeitsregelung - Lösung..................................................................... 46

8.6 L298N-Steuerungsmodul für Gleichstrommotoren im Roboter ....................................... 48


15.07.18 3

8.7 AB 11: Motorsteuerung mit dem L298N-Modul ............................................................... 49

8.8 ABL 11: Motorsteuerung mit dem L298N-Modul - Lösung ............................................... 50

9 Steuerung eines Servomotors .......................................................................................... 51

9.1 AB 12: Servo-Steuerung .................................................................................................... 53

9.2 ABL 12: Servo-Steuerung - Lösung .................................................................................... 55

10 Steuerung eines autonomen Roboters ............................................................................. 62

11 Test der einzelnen Komponenten des autonomen Roboters ............................................. 67

12 Arduino-Glossar .............................................................................................................. 77


15.07.18 4

1 Arduino

Der Arduino ist eine Platine mit einem Mikrocontroller. Er wird mit dem USB-Port des Computers verbunden. Mithilfe eines C++ Computerprogramms kann man beim Arduino die Digitalpins auf 5 V (HIGH) oder auf 0 V (LOW) schalten. Damit kann man eine LED einschalten und ausschalten. Auf dem Bildschirm erscheint nach dem Arduino-Start diese Entwicklungsumgebung mit den beiden Funktionen setup und loop. void setup() {

// put your setup code here, to run once:

}

void loop() {

// put your main code here, to run repeatedly:

}

Entspricht dem Minuspol einer Batterie

Digitalpins entsprechen dem Pluspol einer Batterie

An

alo

gp

ins

Ein

gan

g m

it A/D

Wan

dle

r 0...5

V z

u 0

...102

3 V


15.07.18 5

2 Blinkende LED Wir wollen eine LED ein- und ausschalten. Dazu schließen wir die LED an Digitalpin 12 des Arduino an und teilen dem Arduino in der setup-Funktion durch den Befehl

pinMode(12,OUTPUT) mit, dass er auf diesem Pin die Steuerung für die LED ausgeben soll. In der loop-Funktion soll der Arduino dann die LED immer wieder

einschalten und ausschalten. Eingeschaltet wird die LED mit digitalWrite(12,HIGH) und ausgeschaltet mit digitalWrite(12,LOW). Mit dem Befehl delay(1000) kann eine Sekunde lang gewartet werden, bis die LED umgeschaltet

wird. So sieht dann das ganze Arduino-Programm aus: void setup() {


pinMode(12, OUTPUT);

}

void loop() {


digitalWrite(12, HIGH);

delay(1000);

digitalWrite(12, LOW);

delay(1000);

}

Nach der Erstellung des Programms muss es übersetzt und auf den Mikrocontroller des Arduino geladen werden. Im Kopfmenü der Entwicklungsumgebung können diese Optionen mit einem Mausklick gewählt werden. Außerdem werden wir aufgefordert das Programm auf dem Rechner zu speichern.

Beim Hochladen auf den Mikrocontroller muss der Arduino den passenden Port der USB-Verbindung erhalten. Bei einer Fehlermeldung muss dieser Port über die Menü-Punkte „Werkzeuge“ – „Port“ ausgewählt werden.


15.07.18 6

Weitere Optionen stehen zur Verfügung. „Neu“ führt zur Erstellung eines neuen Programms. „Öffnen“ kann zum Laden eines Programms vom Rechner verwendet werden. Mit „Speichern unter...“ kann das Programm unter einem neuen Namen auf dem Rechner abgespeichert werden.

Mit dem folgenden Schaltplan kann auf dem Breadboard der Stromkreis aufgebaut werden. Am Pin 12 sind 5 V, wenn die LED leuchten soll, und 0 V, wenn die LED nicht leuchten soll.


15.07.18 7

2.1 AB 1: Blinkende LED

Material: 1 Laptop mit Arduino-Programm 1 Arduino 1 Breadboard 1 rote LED

1 Widerstand ( 200 Ω) verschiedene Breadboard Kabel für den Arduino

Aufgabe 1: Schreibe auf dem Laptop das Arduino-Programm mit dem die LED 1 Sekunde leuchtet und 1 Sekunde ausgeschaltet ist. Aufgabe 2: Baue die Schaltung nach dem Schaltplan auf dem Breadboard. Starte das Arduino-Programm. Wenn das Arduino-Programm läuft, kannst du es so abändern, dass die LED verschieden schnell blinkt.


15.07.18 8

2.2 ABL 1: Blinkende LED - Lösung Mögliche Schaltung:

Die horizontalen Reihen oben und unten sind durchgängig leitend verbunden. Sie eignen sich für Verbindungen zu GND (Minuspol) oder zum Pluspol. Die vertikalen Kontaktspalten sind in zwei Bereiche aufgeteilt und jeweils mit fünf Kontaktlöchern leitend verbunden.


15.07.18 9

3 Messen mit dem Multimeter

Ein Multimeter braucht man um die Größe von Spannungen oder von Widerständen in unseren Experimenten bestimmen zu können. Um Spannungen zu messen, muss man den Drehschalter auf

einstellen. Um Widerstände zu messen muss man den Drehschalter auf

einstellen. Das Multimeter gibt die Spannungen und Widerstandswerte als Dezimalzahlen an. 5.0 V oder 4.5 V oder 2.45 V ...

200 oder 9.5 k oder 1.1 k ...

Rechnen mit Dezimalzahlen 4.5 V bedeutet 4 V + 5/10 V. An der ersten Stelle hinter dem Punkt sind die 1/10 V Werte. 4.49 V bedeutet 4 V + 4/10 V + 9/100 V. An der zweiten Stelle hinter dem Punkt sind die 1/100 V Werte. Bei den Widerstandswerten ist es ganz ähnlich.

9.5 k bedeutet 9 k + 5/10 k.

9.19 k bedeutet 9 k + 1/10 k + 9/100 k. Damit wir einen besseren Überblick haben, runden wir meistens auf eine Stelle hinter

dem Punkt. 4.49 V 4.5 V oder 9.19 k 9.2 k


15.07.18 10

4 Lauflicht mit LEDs Verschiedenfarbige LEDs sollen der Reihe nach eine vorgegebene Zeit leuchten. Wir verwenden eine rote, eine gelbe, eine grüne, eine blaue und eine weiße LED. Die rote LED wird an den Pin 0, die gelbe LED wird an den Pin 1, die grüne LED wird an den Pin 2, die blaue LED an den Pin 3 und die weiße LED an den Pin 4 angeschlossen. Jeder dieser Pins von 0 bis 4 muss in der setup-Funktion auf OUTPUT eingestellt werden. In der loop-Funktion kannst du dann z. B. für die grüne LED an Pin 2 die folgenden drei Befehle eingeben:


delay(500);



15.07.18 11

4.1 AB 2a: Lauflicht Material: 1 Laptop mit Arduino-Programm 1 Arduino 1 Breadboard 1 rote LED 1 gelbe LED 1 grüne LED 1 blaue LED 1 weiße LED

5 Widerstände ( 200 Ω) verschiedene Breadboard Kabel für den Arduino

Aufgaben: 1) Schreibe das Arduino-Programm, mit dem die LEDs der Reihe nach eingeschaltet

und ausgeschaltet werden.

2) Baue auf dem Breadboard die Schaltung auf. Jede LED braucht einen Vorwiderstand

von etwa 200 . Überprüfe mit dem Multimeter die Widerstände.

3) Lade das Arduino-Programm auf den Mikrocontroller. Starte das Experiment.


15.07.18 12

4.2 ABL 2a: Lauflicht - Lösung

Aufgabe 1:

void setup() {


pinMode(0, OUTPUT); // rote LED

pinMode(1, OUTPUT); // gelbe LED

pinMode(2, OUTPUT); // grüne LED

pinMode(3, OUTPUT); // blaue LED

pinMode(4, OUTPUT); // weiße LED

}

void loop() {


digitalWrite(0, HIGH); delay(300); digitalWrite(0, LOW);





}

In diesem Arduino-Programm leuchtet jede LED 300 ms lang. Aufgabe 2: Eine möglicher experimenteller Aufbau des LED-Lauflichts


15.07.18 13

4.3 AB 2b: Lauflicht – Programm mit „for-Schleife“

Anstatt für jeden einzelnen Pin die Anweisungen zum Ein- und Ausschalten zu schreiben, kann man auch eine for-Schleife verwenden.

Arudino-Programm mit for-Schleife:

int i;

void setup() {


for (i = 0; i <= 4; i++) {

pinMode(i, OUTPUT);

}

}

void loop() {


for (i = 0; i <= 4; i++) {

digitalWrite(i, HIGH); delay(500); digitalWrite(i, LOW);

}

}

Für die for-Schleife wird ein Zähler i festgelegt. In der for-Schleife steht zuerst der

Startwert von i. Danach folgt die Abfrage, ob die Pin-Nummer 4 schon überschritten ist.

Solange i <= 4 ist, kann mit i++ der Zähler i um 1 erhöht werden. Die einzelnen Teile in der

for-Schleife werden mit einem ; getrennt.

Aufgabe: Teste das Programm.


15.07.18 14

4.4 AB 3: Ampelsteuerung Mit der folgenden Schaltung kann eine Ampelsteuerung gebaut werden.

Aufgaben: 1) Erstelle ein Arduino-Programm, bei dem das rote Licht der Ampel 10 s, das gelbe

Licht der Ampel 1 s und das grüne Licht 5 s leuchtet. Die Ampel soll folgenden Ablauf haben: a. Die Ampel startet mit „rot“. b. Danach leuchten „rot“ und „gelb“. c. Danach leuchtet nur „grün“. d. Danach leuchtet nur „gelb“ e. Danach schaltet die Ampel wieder auf „rot“.

2) Mache einen experimentellen Aufbau und teste die Ampel.


15.07.18 15

4.5 ABL 3: Ampelsteuerung - Lösung

void setup() {


pinMode(0, OUTPUT); //rot

pinMode(1, OUTPUT); //gelb

pinMode(2, OUTPUT); //grün

}

void loop() {


digitalWrite(0, HIGH); delay(10000);


digitalWrite(0, LOW); digitalWrite(1, LOW);





}

Das Programm wird klarer, wenn für die Pins 0, 1, 2 Namen für die Ampelfarben eingesetzt werden. Da 0, 1, 2 ganze Zahlen sind, definieren wir die Platzhalter rot, gelb, gruen am Programmbeginn. Beachte, dass im Arduino-Programm, das die C++ Programmiersprache verwendet, keine Umlaute in den Namen der Platzhalter verwendet werden dürfen.

int rot = 0;

int gelb = 1;

int gruen = 2;

void setup() {

pinMode(rot, OUTPUT);

pinMode(gelb, OUTPUT);

pinMode(gruen, OUTPUT);

digitalWrite(rot, HIGH);

digitalWrite(gelb, LOW);

digitalWrite(gruen, LOW);

}

void loop() {

digitalWrite(rot, HIGH); delay(10000);

digitalWrite(gelb, HIGH); delay(1000);

digitalWrite(rot, LOW); digitalWrite(gelb, LOW);

digitalWrite(gruen, HIGH); delay(5000);

digitalWrite(gruen, LOW);

digitalWrite(gelb, HIGH); delay(1000);

digitalWrite(gelb, LOW);

}


15.07.18 16

4.6 AB 4: Spannungen in der Reihenschaltung Material:

2 Widerstände 1 k

2 Widerstände 10 k

1 Widerstand 100

1 Widerstand 220

1 Arduino 1 Breadboard verschiedene Breadboard Kabel für den Arduino 1 Multimeter

Aufgabe 1: Baue nach den Schaltbildern in der linken Spalte die zugehörigen Schaltungen auf dem Breadboard auf. Miss dann jeweils die Spannung

• zwischen dem Pin 5 V1 und dem Pin GND

• zwischen dem Pin 5 V und der Stelle M

• zwischen der Stelle M und dem Pin GND. Trage die Spannungswerte auf der rechten Seite der Tabelle ein.

U5V-GND U5V-M UM-GND




Wenn man zwischen Pin 5 V und GND zwei gleichgroße Widerstände schaltet, wird die

Spannung von 5 V in zwei ______________________ Teile aufgeteilt.

Wenn der Widerstand zwischen dem Pin 5 V und der Mitte M kleiner ist als der

Widerstand zwischen M und dem Pin GND, dann ist die Spannung zwischen M und GND

_____________ als zwischen dem Pin 5 V und M.

1 Dieser Pin 5 V wird verwendet, wenn konstant die Spannung 5 V angelegt wird.


15.07.18 17

Wenn der Widerstand zwischen dem Pin 5 V und der Mitte M größer ist als der

Widerstand zwischen M und dem Pin GND, dann ist die Spannung zwischen M und GND

_____________ als zwischen dem Pin 5 V und M.

Aufgabe 2: Wir verwenden jetzt einen LDR-Widerstand, der bei Dunkelheit seinen größten und bei Helligkeit seinen kleinsten Widerstand hat. LDR ist die Abkürzung für Light Dependant Resistor. Baue nach dem folgenden Schaltbild die zugehörige Schaltung auf dem Breadboard auf und miss mit dem Multimeter bei Dunkelheit und bei Helligkeit jeweils die Spannung

• zwischen dem Pin 5 V und dem Pin GND


• zwischen der Stelle M und dem Pin GND.

Bei Dunkelheit Bei Helligkeit

U5V-GND

U5V-M UM-GND U5V-GND U5V-M UM-GND


15.07.18 18

4.7 ABL 4: Spannungen in der Reihenschaltung - Lösung Aufgabe 1: Baue nach den Schaltbildern in der linken Spalte die zugehörigen Schaltungen auf dem Breadboard auf. Miss dann jeweils die Spannung

• zwischen dem Pin 5 V und dem Pin GND


• zwischen der Stelle M und dem Pin GND. Trage die Spannungswerte auf der rechten Seite der Tabelle ein.

U5V-GND

5 V

U5V-M

2.5 V

UM-GND

2.5 V

U5V-GND

5 V

U5V-M

2.5 V

UM-GND

2.5 V

U5V-GND

5 V

U5V-M

0.5 V

UM-GND

4.5 V

U5V-GND

5 V

U5V-M

4.1 V

UM-GND

0.9 V

Die Messwerte für U5V-M und UM-GND können leicht variieren. Wenn man zwischen Pin 5 V und GND zwei gleich große Widerstände schaltet, wird die Spannung von 5 V in zwei gleich große Teile aufgeteilt. Wenn der Widerstand zwischen dem Pin 5 V und der Mitte M kleiner ist als der Widerstand zwischen M und dem Pin GND, dann ist die Spannung zwischen M und GND größer als zwischen dem Pin 5 V und M. Wenn der Widerstand zwischen dem Pin 5 V und der Mitte M größer ist als der Widerstand zwischen M und dem Pin GND, dann ist die Spannung zwischen M und GND kleiner als zwischen dem Pin 5 V und M.


15.07.18 19

Aufgabe 2:

Bei Dunkelheit Bei Helligkeit

U5V-GND

5 V

U5V-M

4.7 V

UM-GND

0.3 V

U5V-GND

5 V

U5V-M

1.2 V

UM-GND

3.8 V

Die Messwerte für U5V-M und UM-GND variieren je nach Grad der Dunkelheit und Helligkeit. Möglicher experimenteller Aufbau für eine Reihenschaltung:

UM-GND

U5V-M UM-GND


15.07.18 20

5 Analog-Digital-Wandler im Arduino An den Pins A0 bis A5 ist im Arduino jeweils ein 10-bit-Analog-Digital-Wandler angeschlossen. Das bedeutet, dass der Arduino die Spannungen zwischen 0.0 V und 5.0 V automatisch in 210 = 1024 Integerwerte von 0 bis 1023 umwandelt. Wenn die Spannung 2.5 V beträgt, dann bildet der Arduino die Zahl 512. Da jedes Gerät kleine Toleranzen hat, kann der Arduino auch 511 oder 513 anzeigen. Die 1024

Integerwerte sind in 5

1024 V 0.0049 V = 4.9 mV Portionen aufgeteilt.

Jetzt bestimmen wir die Spannungswerte zwischen M und GND mit dem Arduino, indem wir den Punkt M mit dem Analogeingang A0 des Arduino verbinden.

Wenn wir M mit dem Analogeingang A0 verbinden, wird mit Hilfe des Analog-Digital-Wandlers (AD-Wandler) automatisch für die Spannung zwischen M und GND eine Integerzahl zwischen 0 und 1023 vom Arduino bestimmt. Diese Zahl kann man auf dem Bildschirm des Laptop ausgeben. Dazu benutzt man die serielle USB-Verbindung zwischen Arduino und Laptop.


15.07.18 21

5.1 AB 5: Ausgabe der AD-Werte

Mit dem folgenden Programm kann man die Integerwerte des AD-Wandlers für die Spannung zwischen M und GND ausgeben. 1) int sensorWert; // Variable für den Sensorwert 2) void setup() { 3) Serial.begin(9600); 4) } 5) 6) void loop() { 7) sensorWert = analogRead(A0); 8) // Spannung mit AD-Wandler am Pin A0 messen 9) Serial.print(“Sensorwert = “); 10) // den Text zwischen den Anführungszeichen ausgeben 11) Serial.println(sensorWert); 12) // Spannung als Integerzahl des AD-Wandlers ausgeben 13) delay(500); 14) }

Erläuterungen zu den Programmzeilen Zeile 1) Die vom AD-Wandler bestimmte Zahl zwischen 0 und 1023 soll in einem ganzzahligen Speicherplatz mit dem Namen „sensorWert“ abgelegt werden. Deshalb schreiben wir am Programmanfang die Anweisung: int sensorWert; Zeile 3) In der setup-Funktion initialisieren wir die serielle Verbindung mit Serial.begin(9600), d. h. die Daten werden mit einer Geschwindigkeit von 9600 Bit/Sekunde übertragen. Da für ein Zeichen (z. B. A) 8 Bit erforderlich sind, werden 9600/8 = 1200 Zeichen/Sekunde übertragen. Zeile 6) bis 13) In der loop-Funktion können wir dann mit Serial.print oder mit Serial.println die Zahlenwerte ausgeben. Bei Serial.println geht der Cursor nach der Ausgabe des Zahlenwertes an den Anfang der nächsten Zeile.


15.07.18 22

Aufgabe 1: Schreibe das C++ Programm und teste es mit deiner Schaltung. Aufgabe 2: Erweitere das C++ Programm so, dass neben den ganzzahligen Sensorwerten zwischen 0 und 1023, die im Speicherplatz sensorWert abgelegt werden, auch die zugehörigen Spannungswerte berechnet und ausgegeben werden. Die Spannungswerte sollen in einem Speicherplatz mit dem Namen spannungWert abgelegt werden. Da die Spannungswerte normalerweise keine ganzen Zahlen sind, müssen wir für sie einen Speicherplatz festlegen, in dem eine Dezimalzahl stehen kann. An den Programmanfang setzen wir dazu eine weitere Anweisung mit double spannungWert; Im C++ Programm wird der Spannungswert ausgerechnet mit der Anweisung:

spannungWert = sensorWert * 5/1024;

Wichtiger Hinweis: Da die Variable sensorWert und die anderen Zahlen in diesem Ausdruck alle vom Typ Integer sind, rechnet C++ nur mit ganzen Zahlen. Bei einem sensorWert = 300 würde C++ den Zahlenwert 1 liefern. Wir müssen C++ darauf hinweisen, dass hier mit Dezimalzahlen zu rechnen ist. Dazu gibt man folgenden Befehl ein:

static_cast<double>(sensorWert) * 5/1024;

Mit static_cast<double> drückt man in C++ aus, dass sensorWert als Dezimalzahl behandelt werden soll. Danach weiß C++, dass der gesamte Term mit Dezimalzahlen gerechnet werden muss.


15.07.18 23

5.2 ABL 5: Ausgabe der AD-Werte - Lösung Aufgabe 2:

int sensorWert; // Variable für den Sensorwert

int spannungWert; // Spannung zwischen M und GND

int analogPin = A0; // Analogpin A0 für Aufnahme der Spannungen

void setup() // Hier beginnt das Setup

{

Serial.begin(9600); // Serielle Ausgabe initialisieren

}

void loop()

{

sensorWert = analogRead(analogPin);

// Die Spannung an dem Fotowiderstand auslesen

Serial.print("Sensorwert = ");

// Ausgabe am Serial-Monitor: Das Wort Sensorwert:

Serial.print(sensorWert);

// Sensorwert des Fotowiderstandes als integer Zahl

spannungWert = static_cast<double>(sensorWert)*5/1024;

Serial.print(" ");

Serial.print(spannungWert);

Serial.println(" V"); delay(500); }


15.07.18 24

5.3 AB 6: LED bei Dunkelheit einschalten

Um bei einem bestimmten Sensorwert eine LED einzuschalten, schließen wir eine LED an den Digitalpin 10.

Wenn der LDR nur noch schwach beleuchtet wird, ist es dunkel und sein Widerstand ist groß. Wie wir wissen, ist dann bei M die Spannung klein, d. h. der digitale Sensorwert ist z. B. kleiner als 300. Im folgenden Programm wird für einem Sensorwert von weniger als 300 die LED eingeschaltet. Die zugehörige Anweisung im Programm ist:

if (sensorWert < 300)

{

digitalWrite(10,HIGH); // LED einschalten

}

Die Bedingung (sensorWert < 300) muss in runden Klammern hinter if stehen!

Alle Anweisungen, die zu if gehören, setzt man in geschweifte Klammern { ... }. Falls die Bedingung nicht erfüllt ist, kann mit else die Anweisung zum Ausschalten der LED aufgerufen werden. Auch nach else setzt man die Anweisungen in geschweifte Klammern { ... }.


15.07.18 25


int analogPin = A0; // Analogpin A0 für Aufnahme der Spannungen

int ledPin = 10; // Digitalpin 10 für die LED

void setup() {

Serial.begin(9600);

pinMode(ledPin, OUTPUT);

}

void loop() {

sensorWert = analogRead(analogPin); // Spannung messen

Serial.print(“Sensorwert = “);

Serial.println(sensorWert); // Spannung ausgeben


{

digitalWrite(ledPin, HIGH); // LED einschalten

}

else

{

digitalWrite(ledPin, LOW); // LED ausschalten

}

delay(500);

}

Aufgabe: Baue nach der Schaltskizze die Schaltung auf dem Breadboard auf. Teste das Programm mit deiner Schaltung. Möglicherweise musst du den Sensorwert noch anpassen, damit die LED bei Dunkelheit aufleuchtet und bei Helligkeit ausgeht. Zusatzaufgabe: Verwende außer der LED noch einen Piezo-Lautsprecher, der eingeschaltet wird, wenn es dunkel wird. Der Piezo-Lautsprecher wird wie im folgenden Schaltbild zwischen den Pin 8 und GND geschaltet:

Mit dem Befehl tone(8, 440); wird über den Pin 8 mit dem Piezo-Lautsprecher ein Ton mit einer Tonhöhe von 440 Hz (Hertz) eingeschaltet. Dieser Ton heißt Kammerton. Mit noTone(8); kann der Ton über den Pin 8 wieder abgeschaltet werden. Schreibe das Programm für den Piezo-Lautsprecher entsprechend um.


15.07.18 26

5.4 ABL 6: LED bei Dunkelheit einschalten - Lösung

Aufgabe

Zusatzaufgabe


15.07.18 27


int analogPin = A0; // Analogpin 0 für Aufnahme der Spannungen

int ledPin = 10; // Digitalpin 10 für die LED

int piezoPin = 8; // Digitalpin 10 für den Piezo

void setup() {

Serial.begin(9600);

pinMode(ledPin, OUTPUT);

pinMode(piezoPin, OUTPUT);

}

void loop() {

sensorWert = analogRead(analogPin); // Spannung messen

Serial.print(“Sensorwert = “);

Serial.println(sensorWert); // Spannung ausgeben


{

digitalWrite(ledPin, HIGH); // LED einschalten

tone(8, 440); // Piezo mit 440 Hz einschalten

delay(2000); // 2 Sekunden zuwarten

noTone(8); // Piezo ausschalten

}

else

{

digitalWrite(ledPin, LOW); // LED ausschalten

}

delay(500);

}


15.07.18 28

6 Bewegungsmelder Beim Arduino kann man einen Bewegungsmelder einfach mit einem PIR (Passive InfraRed) Sensor steuern. Sobald der PIR eine Bewegung eines Lebewesens erkennt, gibt er ein Signal von 5 V aus, sonst gibt er 0 V aus. Dieses Signal liest man an einem Digitalpin ein (digitalRead) und kann dann eine LED einschalten (digitalWrite) oder einen Piezo-Lautsprecher ertönen (tone) lassen.


15.07.18 29

6.1 AB 7: Alarmanlage

Aufgabe 1: Baue nach der Schaltskizze die Schaltung auf dem Breadboard auf.

Das Signal des Bewegungssensors kommt am Digitalpin 7 an. Da der Arduino ein digitales Signal von 5 V einliest, müssen wir in der setup-Funktion eine pinMode-Anweisung pinMode(7, INPUT); eintragen. Der Piezo-Lautsprecher wird am Pin 5 angeschlossen. Die LED wird am Pin 9 angeschlossen. Aufgabe 2: 1) Schreibe die pinMode-Anweisungen in die setup-Funktion für das Signal des

Bewegungssensors, den Piezo-Lautsprecher und die LED auf.

Mit der Anweisung status = digitalRead(7); wird der Signalwert auf Pin 7 eingelesen und in einem Speicherplatz mit dem Namen status abgespeichert. Für 0 V wird die Zahl 0 abgespeichert. Für 5 V wird die Zahl 1 abgespeichert. status hat also nur die zwei ganzen Zahlenwerte 0 oder 1. Deshalb muss status ganz am Anfang des Programms als Integerzahl festgelegt werden mit der Anweisung: int status; Für den Zahlenwert 1 kann HIGH und für den Zahlenwert 0 kann LOW im Programm

geschrieben werden.

Wenn status auf HIGH ist, soll die LED für 5 s aufleuchten und der Piezo-Lautsprecher für 5 s tönen. Als Tonfrequenz soll z.B. 440 Hz gewählt werden. Wenn status auf LOW ist, sollen LED und Piezo-Lautsprecher ausgeschaltet werden.


15.07.18 30

In C++ lauten die Anweisungen dazu:

if (status == HIGH)

{

tone(5, 440); // Tonhöhe von 440 Hz

digitalWrite(9, HIGH); // LED einschalten

delay(5000); // 5 Sekunden Dauer

noTone(5); // Dauerton ausschalten

digitalWrite(9, LOW); // LED ausschalten

}

else

{



}

2) Versuche das Programm zu erstellen, indem du deine Anweisungen in die setup-

Funktion und in die loop-Funktion einträgst. Teste es mit deinem experimentellen

Aufbau. Beachte: a) Nicht vergessen: Die Anweisung int status; muss am Anfang des Programms

stehen. b) Die Bedingung status == HIGH muss in runden Klammern hinter if stehen!

Beim Vergleich muss ein doppeltes Gleichheitszeichen verwendet werden! Die Anweisungen hinter der if-else-Anweisung sind zwischen geschweifte Klammern zu setzen.


15.07.18 31

6.2 ABL 7: Alarmanlage - Lösung Aufgabe 1:


15.07.18 32

Aufgabe 2 und 3: int status; //Signalstatus

void setup() {

pinMode(7, INPUT); // Signal des Bewegungssensors

pinMode(5, OUTPUT); // Piezo

pinMode(9, OUTPUT); // LED

}

void loop() {

status = digitalRead(7);

if (status == HIGH)

{

tone(5, 440);


delay(5000); // 5s Ton und LED

noTone(5); // Ton aus

digitalWrite(9, LOW); // LED aus

}

else

{



}

}


15.07.18 33

7 Entfernungsmessung mit Ultraschall Der Ultraschallsensor HC-SR04 besitzt einen Sender (Trigger) und einen Empfänger (Echo), die ähnlich wie bei einer Fledermaus (Mund = Trigger; Ohren = Echo) funktionieren. Der Ultraschall ist ein Ton mit ca. 40 kHz.

Durch den Trigger wird ein kurzer Impuls von mindestens 10 µs ausgegeben. Kurze Zeit nach dem Abfall der Trigger-Flanke (250 µs) sendet der Ultraschallsensor 200 µs lang ein 40 kHz Burst-Signal (= 8 Perioden). Sofort danach geht der Echo-Eingang auf einen HIGH-Pegel und wartet auf den Empfang des akustischen Echos. Sobald das Echo des Burst-Signals vollständig registriert ist, fällt der Ausgang am Echo auf den LOW-Pegel. Die Distanz d berechnet sich dann aus der Zeit t vom Aussenden des Signals bis zu

seiner Rückkehr mit 𝑑 = 𝑐∙𝑡

2. Die Distanz entspricht nämlich der Hälfte des vom Burst-

Signal zurückgelegten Weges. Die Schallgeschwindigkeit c beträgt bei 20 °C etwa 344 𝑚 𝑠⁄ . Diese Ultraschall-Entfernungsmessung kann zwischen 2 cm und 3 m mit einer

Genauigkeit von etwa 2 mm eingesetzt werden.


15.07.18 34

Um die Pulslänge am Echo-Eingang zu messen, wird die Funktion pulseIn() verwendet. Bei pulseIn(6, HIGH) wartet die Funktion, bis das Signal am Pin 6 auf HIGH geht und startet dann das Timing. Das Timing wird gestoppt, sobald das gesamte Burst-Signal zurück ist. Damit geht das Signal am Pin 6 auf LOW. Das Ergebnis wird in Mikrosekunden geliefert bzw. 0, wenn kein vollständiges Echo des Burst-Signals angekommen ist. Einige Hintergrundinformationen zum Programm 1) Auf dem Arduino Uno werden ganze Zahlen (Integer-Zahlen) als 16 Bit-Wert

abgespeichert. Daraus folgt, dass ein Zahlenbereich von −215 bis +(215 − 1) dargestellt werden kann. 215 = 32768

2) Mit der Definition unsigned int echo; kann die Variable echo Zahlenwerte von 0 bis

+(216 − 1) = 65535 darstellen.

3) Abstandsmessung mit der Schallgeschwindigkeit:

a) Laufzeit des Schalls hin und zurück in Mikrosekunden: dauer

b) Schallgeschwindigkeit bei 20°C: 344 𝑚𝑠⁄ .

In 1 s legt der Schall 344 m zurück. In einer Mikrosekunde legt er nur 0,0344 cm zurück.

c) Für die Entfernung in cm ergibt sich damit: entfernung = 0.0344*(dauer/2);

i. Hier rechnet der C++ Compiler automatisch alles mit double, weil 0.0344 eine

Dezimalzahl ist. ii. Wenn das Echo nicht vollständig zurückkommt (z.B. Reflexion an einem

Schwamm), liefert pulseIn als Ergebnis die Integerzahl 0. iii. Das HC-SR04 kann Entfernungen von 2 cm bis 300 cm durch Reflexion an

glatten, ebenen Flächen zuverlässig messen. Bei Reflexionen an weichen oder porösen Oberflächen (z. B. Schwamm) kommt es leicht zu Messfehlern. Nur wenn dauer != 0 (ungleich 0) ist, können sinnvolle Entfernungen gemessen werden.

d) Temperaturabhängigkeit der Schallgeschwindigkeit: 𝑐𝐿𝑢𝑓𝑡 ≈ (331,5 + 0,6𝜗) 𝑚

𝑠⁄ mit 𝜗 in °C


15.07.18 35

7.1 AB 8: Entfernungsmesser mit Ultraschall Aufgabe 1: Baue die Schaltung des HC-SR04 auf dem Breadboard auf und verbinde mit dem Arduino. Aufgabe 2: Schreibe ein Programm zur Entfernungsmessung. Folgende Hinweise können dir helfen: 1) Festlegung von Variablen

Weise mit folgenden Anweisungen für den Pin 7 der Variablen trigger die Zahl 7 und für den Pin 6 der Variablen echo die Zahl 6 zu. Die Laufzeit des Schalls wird als

ganze Zahl in Mikrosekunden gemessen. Wir nennen die zugehörige Variable dauer. Die Entfernung ist eine Dezimalzahl und wird deshalb mit einer Variablen vom Typ double bearbeitet. Diese Variablen müssen ganz am Anfang des Programms, also vor der setup-Funktion, stehen.

int trigger = 7; //Trigger-Pin des Ultraschallsensors

int echo = 6; // Echo-Pin des Ultraschallsensors

int dauer; // Laufzeit des Schallsignals

double entfernung; // Berechnete Entfernung

2) Initialisierungen

trigger muss auf OUTPUT und echo auf INPUT initialisiert werden. Damit wir die Messwerte auf dem Bildschirm des Computers lesen können, verwenden wir die Ausgabe über die USB-Verbindung. Diese muss initialisiert werden mit:

Serial.begin(9600);

3) Schreibe die Anweisungen zur Entfernungsmessung in die loop-Funktion

Gehe dazu in folgenden Schritten vor:

a. Setze den Trigger auf LOW. Warte zwei Millisekunden und setze dann den Trigger auf HIGH. Halte mit delayMicroseconds(10) den Trigger für 10 µs auf HIGH. Setze danach den trigger wieder auf LOW.

b. Miss mit folgender Anweisung die Laufzeit des Schalls in Mikrosekunden:

dauer = pulseIn(echo, HIGH);

c. Berechne mit folgender Anweisung die Entfernung:

entfernung = 0.0344*(dauer/2);


15.07.18 36

d. Lege mit Hilfe von if-else-Anweisungen folgendes fest: Wenn kein Messfehler festgestellt wird (dauer != 0) und wenn die Entfernung

zwischen 2 cm und 300 cm liegt, gibst du die Entfernung mit folgenden Anweisungen aus:

Serial.print("Entfernung = ");

Serial.print(entfernung);

Serial.println(" cm");

e. Sonst soll auf dem Bildschirm mit Serial.println("kein Messwert!") eine Fehlermeldung erscheinen.

f. Nach einer Entfernungsmessung lässt du das Programm 3 s pausieren, bis du wieder eine neue Messung machst.


15.07.18 37

7.2 ABL 8: Entfernungsmesser mit Ultraschall - Lösung Aufgabe 1:


15.07.18 38

Aufgabe 2: int trigger = 7; // Trigger-Pin des Ultraschallsensors


int dauer; // Laufzeit des Schallsignals in Mikrosek.

double entfernung; // Berechnete Entfernung

void setup() {

pinMode(trigger, OUTPUT);

pinMode(echo, INPUT);

Serial.begin(9600);

}

void loop() {

digitalWrite(trigger, LOW);

delay(2);

digitalWrite(trigger, HIGH);

delayMicroseconds(10);

digitalWrite(trigger, LOW);

// Triggersignal auf LOW.

// Nach 250 Mikrosek. wird das Burstsignal ausgesandt

dauer = pulseIn(echo, HIGH);

// Der Echo-Eingang wird sofort danach auf HIGH geschaltet

// Sobald der gesamte Burst zurück ist, auf LOW

entfernung = 0.0344*(dauer/2);

if ((dauer != 0) && (entfernung < 300) && (entfernung > 2))

{




}

else

{

Serial.println("Kein Messwert!");

}

delay(3000);

}


15.07.18 39

8 Steuerung eines Gleichstrommotors Die meisten Elektromotoren können mit den kleinen Stromstärken des Arduino (maximal 40 mA) nicht betrieben werden. Wir müssen deshalb sogenannte Motortreiber einsetzen. Mit dem Motortreiber L293D lassen sich zwei Gleichstrommotoren bis zu einer Stromstärke von 0.6 A verwenden. Aus dem Datenblatt kann die Belegung der L293D Pins entnommen werden.

L293D- Pin

Name

16 VCC1 Versorgungsspannung (4.5 V bis 36 V) für den L293D.

8 VCC2 Versorgungsspannung für die Motoren (4.5 V bis 36 V). Externe Spannungen möglich

1, 9 EN Enable-Pin des L293D. HIGH (5 V) aktiviert den L293D und aktiviert die Motor- Pins. Pin 1 ist für die Motorpins 3 und 6 zuständig. Pin 9 ist für die Motorpins 11 und 14 zuständig. LOW deaktiviert die Motoren entsprechend.

2, 7 1A, 2A Setzt man 1A auf LOW und 2A auf HIGH, dann dreht sich der Motor M1 in eine Richtung. Vertauscht man HIGH und LOW, dann vertauscht der Motor M1 seine Drehrichtung. Bei LOW-LOW oder HIGH-HIGH steht der Motor.

10, 15 3A, 4A Setzt man 3A auf LOW und 4A auf HIGH, dann dreht sich der Motor M2 in eine Richtung. Vertauscht man HIGH und LOW, dann vertauscht der Motor M2 seine Drehrichtung. Bei LOW-LOW oder HIGH-HIGH steht der Motor.

3, 6 1Y, 2Y Hier wird das Signal von 1A und 2A für den Motor M1 ausgegeben.

11, 14 3Y, 4Y Hier wird das Signal von 3A und 4A für den Motor M2 ausgegeben.

4, 5, 12,13

GND Alle verwendeten GND-Pins müssen miteinander verbunden werden (L293D, Arduino, externes Netzteil)


15.07.18 40

8.1 AB 9: Gleichstrommotor mit Richtungswechsel Versuchsaufbau: Wir setzen einen Gleichstrommotor (RS Pro Nr. 238-9721, Versorgungsspannung 3-7.2 V) über den Anschluss M1 des Treiberbausteins L293D in Gang. Auf die Motorachse stecken wir einen Propeller.


15.07.18 41

In der folgenden Schaltskizze sind die vorgesehenen Anschlüsse am L293D und Pin-Belegungen am Arduino zu entnehmen. Aufgabe 1: Schließe den Elektromotor wie in der Schaltskizze dargestellt an. Die Versorgungsspannung der Motoren liefert ein Netzgerät. Stelle am Netzgerät eine Spannung von 4 V ein. Verbinde den Pluspol des Netzgeräts mit dem Pin 8 des L293D und den Minuspol des Netzgeräts mit GND des Arduino auf dem Breadboard.

a) Durch die direkte Verbindung von Pin 16 mit Pin 1 wird der L293D und der Anschluss

des Motors M1 startklar gemacht. b) Wenn man am L293D Pin 2 auf LOW und Pin 7 auf HIGH setzt, dreht sich der Motor

links oder rechts herum. Wenn man am L293D Pin 2 auf HIGH und Pin 7 auf LOW setzt, dann dreht sich der Motor _______________________ .

c) Verbinde den Pin 1A des L293D mit dem Pin 2 am Arduino und den Pin 2A am L293D mit dem Pin 7 am Arduino. Damit sind die Pin-Nummern am L293D und am Arduino identisch.

Aufgabe 2: Erstelle ein Programm, mit dem der Motor folgendermaßen gesteuert wird: a) Motor dreht 3 s in links oder rechts herum b) Motor stoppt 3 s c) Motor dreht 3 s in umgekehrter Richtung d) Motor stoppt 3 s Beachte folgende Programmierhinweise: Setze Pin 2 und Pin 7 in der setup-Funktion auf OUTPUT.


15.07.18 42

8.2 ABL 9: Gleichstrommotor mit Richtungswechsel - Lösung

Aufgabe 1:

Aufgabe 2: void setup() {

pinMode(2, OUTPUT);

pinMode(7, OUTPUT);

}

void loop() {



delay(3000);



delay(3000);


digitalWrite(7 HIGH);

delay(3000);



delay(3000);

}

Netzgerät


15.07.18 43

8.3 Regulierung der Geschwindigkeit des Gleichstrommotors

Die Drehzahl des Gleichstrommotors kann elegant geregelt werden, indem der Enable-Pin des L293D an einen der PWM-Pins des Arduino angeschlossen wird. Mit der Pulsweitenmodulation wird der Motor in regelmäßigen Zeitspannen ein- und ausgeschaltet. Die Pulsweiten können von 0 bis 255 eingeteilt werden. Bei einer Pulsweite 255 handelt es sich um ein konstantes HIGH-Signal und bei einer Pulsweite 0 um ein konstantes LOW-Signal. Die Zahlenwerte für die Pulsweiten zwischen 0 und 255 müssen mit analogWrite(...) ausgegeben werden, weil es nicht wie bei digitalWrite(...) nur die zwei Werte LOW und HIGH bzw. 0 V und 5 V sind. Der Analogwert wird dann an den Enable-Pin 1 des L293D weitergegeben. Hintergrundinformation: Bei der Pulsweitenmodulation (PWM) des Arduino wird ein Rechtecksignal, das eine feste Frequenz und eine Ausgangsspannung von 0 V bzw. 5 V hat, in der Breite der Pulse variiert. Beim Arduino Uno arbeitet diese PWM an den Pins 3, 5, 6, 9, 10 und 11. Die PWM Frequenz beträgt ungefähr 500 Hz, d. h. die Periodendauer ungefähr 2 ms.


15.07.18 44

8.4 AB 10: Geschwindigkeitsregelung Aufgabe 1: Schließe den Elektromotor wie in der Schaltskizze dargestellt an. Die Versorgungsspannung der Motoren liefert ein Netzgerät. Stelle am Netzgerät eine Spannung von 4 V ein. Verbinde den Pluspol des Netzgeräts mit dem Pin 8 des L293D und den Minuspol des Netzgeräts mit GND des Arduino auf dem Breadboard. Welcher Zahlenwert muss für die PWM mit analogWrite ausgegeben werden, um die eine mittlere Motorspannung von 3 V zu bekommen? _______________ Hinweis: Die Versorgungsspannung der Motoren hat die gleiche PWM wie die 5 V Enable-Spannung. Allerdings beträgt die Amplitude der Motorspannung hier 4 V.

Aufgabe 2: Erstelle ein Programm, das die Geschwindigkeit des Motors folgendermaßen steuert: a. Motor 5 s mit maximaler Geschwindigkeit rechts oder links herum drehen lassen b. Motor stoppt 2 s c. Motor 5 s auf geringere Geschwindigkeit setzen ohne Richtungsänderung d. Motor stoppt 2 s e. Motor 5 s auf maximale Geschwindigkeit setzen in umgekehrter Richtung f. Motor stoppt 2 s g. Motor 5 s auf geringere Geschwindigkeit setzen in umgekehrter Richtung h. Motor stoppt 10 s


15.07.18 45

Beachte folgende Programmierhinweise: 1. Verwende die Variable pinEN für den Pin 1, die Variable pin1A für den Pin 2 und die

Variable pin2A für den Pin 7 beim Arduino. 2. Deklariere diese drei Variablen am Programmanfang. 3. Setze pinEN, pin1A und pin2A in der setup-Funktion auf OUTPUT. 4. Schreibe in die loop-Funktion die Anweisungen für den Enablepin pinEN zur

Geschwindigkeitsregelung, die Motorsteuerpins pin1A und pin2A.


15.07.18 46

8.5 ABL 10: Geschwindigkeitsregelung - Lösung Aufgabe 1:

Netzgerät


15.07.18 47

Aufgabe 2: int pinEN = 9; // zu Enable Pin 1 des L293D

int pin1A = 2; // Arduinopin für Motorrichtung 1A

int pin2A = 7; // Arduinopin für Motorrichtung 2A

void setup() {

pinMode(pinEN, OUTPUT);

pinMode(pin1A, OUTPUT);

pinMode(pin2A, OUTPUT);

}

void loop() {

analogWrite(pinEN, 255); // höchste Geschwindigkeit

digitalWrite(pin1A, HIGH); // links oder rechts herum

digitalWrite(pin2A, LOW);

delay(5000);

digitalWrite(pin1A, LOW); // Motor stoppen


delay(2000);

analogWrite(pinEN, 180); // geringere Geschwindigkeit

digitalWrite(pin1A, HIGH); // ohne Richtungsänderung


delay(5000);



delay(2000);

analogWrite(pinEN, 255); // höchste Geschwindigkeit

digitalWrite(pin1A, LOW); // Richtungswechsel

digitalWrite(pin2A, HIGH);

delay(5000);



delay(2000);

analogWrite(pinEN, 180); // geringere Geschwindigkeit


digitalWrite(pin2A, HIGH);

delay(5000);



delay(10000);

}


15.07.18 48

8.6 L298N-Steuerungsmodul für Gleichstrommotoren im Roboter

In einem Roboter kommen meistens zwei Gleichstrommotoren zum Einsatz. Hierfür kann ein Treibermodul mit einem L293D IC eingesetzt werden. Weit verbreitet sind auch Treibermodule mit L298N ICs. Diese werden oft eingesetzt für Roboter mit zwei Antriebsmotoren.

Das Modul hat je zwei Schraubanschlüsse für den Motor A (OUT1, OUT2) und den Motor B (OUT3, OUT4) und einen weiteren Schraubanschluss für GND, VCC der Motoren und einen 5-V-Schaubanschluss. Eine 5-V-Ausgangsspannung steht nur dann zur Verfügung, wenn die Motoren mit einer Spannung von weniger als 12 V versorgt werden. Da wir für unseren Roboter eine 9-V-Batterie verwenden, setzen wir den Jumper für den 5-V-Regulator und können den 5-V-Ausgang verwenden. Steuerungseingänge des L298N-Moduls Enable A (ENA) und Enable B (ENB) werden verwendet, um die Geschwindigkeiten der Motoren zu steuern. Wir setzen die Jumper bei ENA und ENB. Damit sind ENA und ENB auf 5 V eingestellt. Der Roboter fährt mit maximaler Geschwindigkeit. Da wir den Roboter nur mit 4 x 1.5 V = 6 V betreiben, können wir auch auf eine Geschwindigkeitsregelung verzichten. Die Pins Input 1 (IN1) und Input 2 (IN2) werden verwendet, um die Richtung des Motors A zu steuern. Die Pins Input 3 (IN3) und Input 4 (IN4) werden verwendet, um die Richtung des Motors B zu steuern. Wenn IN1 = LOW und IN2 = HIGH ist, bewegt sich der Motor in eine Richtung. Wenn IN1 = HIGH und IN2 = LOW ist, dreht er sich in die entgegengesetzte Richtung. Wenn beide Inputs entweder LOW oder HIGH sind, stoppt der Motor. Genau so verhält es sich mit IN3 und IN4 und dem Motor B.


15.07.18 49

8.7 AB 11: Motorsteuerung mit dem L298N-Modul Aufgabe 1: Schließe die Motoren wie in der dargestellten Schaltung an. Die Versorgungsspannung der Motoren erfolgt mit vier AA Batterien von jeweils 1.5 V. Verbinde den Pluspol der Versorgungsspannung mit dem +12-V-Schraubpin. An diesem Schraubpin können auch Spannungen von weniger als 12 V angelegt werden. Verbinde den Minuspol der vier AA Batterien mit dem GND des L298N-Moduls und des Arduino.

In der dargestellten Schaltung bestehen folgende Verbindungen zwischen dem L298N Modul und dem Arduino.

L298N-Modul Arduino

IN1 Pin 10

IN2 Pin 9

IN3 Pin 7

IN4 Pin 6

Aufgabe 2: Erstelle ein Arduino-Programm, mit dem die Richtungen von zwei Gleichstrommotoren gesteuert werden können. Die Programmanweisungen sind ähnlich wie im Arbeitsblatt AB 9. Wir müssen nur die Namen der Variablen anpassen.


15.07.18 50

8.8 ABL 11: Motorsteuerung mit dem L298N-Modul - Lösung Aufgabe 2: int IN1 = 10;

int IN2 = 9;

int IN3 = 7;

int IN4 = 6;

void setup() {

pinMode(IN1, OUTPUT);




}

void loop() {

digitalWrite(IN1, HIGH); // Motor A links oder rechts herum

digitalWrite(IN2, LOW);

delay(5000);

digitalWrite(IN1, LOW); // Motor A stoppen


delay(2000);

digitalWrite(IN1, LOW); // Richtungswechsel

digitalWrite(IN2, HIGH);

delay(5000);

digitalWrite(IN1, LOW); // Motor A stoppen


delay(2000);

digitalWrite(IN3, HIGH); // Motor B links oder rechts herum


delay(5000);

digitalWrite(IN3, LOW); // Motor B stoppen


delay(2000);

digitalWrite(IN3, LOW); // Richtungswechsel


delay(5000);

digitalWrite(IN3, LOW); // Motor B stoppen


delay(10000);

}


15.07.18 51

9 Steuerung eines Servomotors

Ein Servomotor, kurz Servo, besteht aus einem Gleichstrommotor und einem Getriebe sowie aus einer Steuerelektronik, welche die Drehung des Motors bestimmt. Die Ansteuerung erfolgt über ein Spannungssignal, das aus Rechteckimpulsen mit Pulsweiten von etwa 1 ms bis zu 2 ms besteht.

Wird die Pulsweite von 1 ms auf 2 ms erhöht, dreht sich der Servo von 0° auf 180°. Um die Pulsweiten mit den Drehwinkeln des Servo zu verbinden, gibt es bei Arduino eine Bibliothek Servo.h mit den notwendigen Funktionen. Am Beginn des Programms wird der

Inhalt der Bibliothek bekanntgemacht durch

#include <Servo.h>


15.07.18 52

Mit dieser Bibliothek können mehrere Servos gesteuert werden. Wir steuern nur einen Servo. Den nennen wir z.B. servoSFZ. Am Programmanfang legen wir dies mit der Vereinbarung

Servo servoSFZ;

fest. Die Ansteuersignale des Servo müssen von einem PWM-Pin des Arduino ausgehen, z. B. Pin 9. Der Übersichtlichkeit halber geben wir dieser Steuerleitung mit der Vereinbarung

int servoSteuer = 9;

den Namen servoSteuer und weisen dabei den Wert 9 zu. Die Ansteuerung des Servo ist aus der folgenden Schaltskizze zu entnehmen:

Im Zusammenhang mit dem Namen servoSFZ können verschiedene Funktionen des Servo aufgerufen werden: 1. In der setup-Funktion wird mit der Anweisung

servoSFZ.attach(servoSteuer);

der Servo mit dem Pin 9 verbunden.

2. In der loop-Funktion kann z.B. durch eine Anweisung

servoSFZ.write(90);

der Servo auf den Winkel von 90° eingestellt werden.

Der Servo wird mit 3 Leitungen versorgt. Der Micro Servo 9g SG90 hat folgende Anschlussbelegungen:

• orange (PWM Signal)

• rot (VCC 5V)

• braun (GND)


15.07.18 53

9.1 AB 12: Servo-Steuerung

Aufgabe 1: Überprüfe mit dem folgenden Programm die Steuerung deines Servo:

// Servo-Ansteuerung mit Servo-Bibliothek

#include <Servo.h> // Servo-Bibliothek wird bekannt gemacht

Servo servoSFZ; // Initialisierung des Objekts servoSFZ

int servoSteuer = 9; // Servo-PWM-Steuerleitung orange

void setup() {

servoSFZ.attach(servoSteuer); // Servo initialisieren

}

void loop() {

servoSFZ.write(0); // Servo auf 0° einstellen

delay(1000);


delay(1000);


delay(1000);

}

Aufgabe 2: Erweitere das Programm so, dass der Servo von 0° bis 180° und anschließend von 180° wieder nach 0° dreht. Nach jedem Grad-Schritt soll der Servo 10 ms warten. Um diese Schritte automatisch ablaufen zu lassen, setze die for-Schleife ein, wie du sie schon beim Lauflicht kennengelernt hast.

Rechtsdrehung von 0° bis 180° Linksdrehung von 180° bis 0°

for(int i = 0; i <= 180; i++)

{

servoSFZ.write(i);

delay(10);

}

for(int i = 180; i >= 0; i--)

{

servoSFZ.write(i);

delay(10);

}


15.07.18 54

Aufgabe 3: Verwende nun einen Servo mit aufgesetztem Gesicht, in das ein Entfernungsmesser eingebaut ist. Erstelle ein Programm das die Entfernung in den Richtungen 0°, 90° und 180° zu dort aufgestellten Gegenständen, z. B. Bücher, misst. Ausgegeben werden soll mit Serial.print und Serial.println die Richtung und der Abstand in Zentimeter.


15.07.18 55

9.2 ABL 12: Servo-Steuerung - Lösung Aufgabe 2:

#include <Servo.h>


Servo servoSFZ; // Servo-Objekt initialisieren

void setup() {


}

void loop() {

for (int i = 0; i <= 180; i++) {

servoSFZ.write(i);

delay(10);

}

for (int i = 180; i >= 0; i--) {

servoSFZ.write(i);

delay(10);

}

}


15.07.18 56

Aufgabe 3: Mögliches Programm in Langversion #include <Servo.h>



int trigger = 7; // Trigger-Pin des Ultraschallsensors


int dauer; // Laufzeit des Schalls in Mikrosekunden

double entfernung; // Entfernung in cm zum Objekt

void setup() {



Serial.begin(9600);


}

void loop() {


digitalWrite(trigger, LOW); // Burst vorbereiten

delay(2);



digitalWrite(trigger, LOW); // Burst startet in 250 Mikrosek.

dauer= pulseIn(echo, HIGH); // Laufzeit in Mikrosekunden

entfernung = dauer*0.0344/2; // Rückgabe der Entfernung in cm

if (entfernung > 300 || entfernung < 2)

{


}

else

{




}

delay(3000);



15.07.18 57


delay(2);







{


}

else

{




}

delay(3000);



delay(2);







{


}

else

{




}

delay(3000);

}


15.07.18 58

Hinweis zu Funktionen: Bei unserem Programm wird für jeden eingestellten Winkel eine Entfernungsmessung und eine Ausgabe der Entfernung durchgeführt. Wir können dies vereinfachen, indem wir für die Entfernungsmessung eine Funktion und für die Ausgabe der Entfernung ebenfalls eine Funktion festlegen. Diese beiden Funktionen können wir dann für jeden eingestellten Winkel aufrufen. Struktur einer Funktion:

Rückgabetyp Funktionsname (Parameterliste) {

.... Anweisungen ....

return Ergebnis;

}

Beispiel:

int laufzeitMessung(int echo) {

// ... Anweisungen ...

return dauer;

}

Wenn eine Funktion kein Ergebnis zurückgibt, steht für den Rückgabetyp void und die letzte Anweisung lautet return oder kann entfallen. Wenn keine Parameter der Funktion übergeben werden, steht zwischen den runden Klammern hinter dem Funktionsnamen void oder kann leer gelassen werden. Beispiel:

void setup(void) {


return;

}

oder

void setup() {


}


15.07.18 59

Für die Funktion zur Entfernungsmessung können wir eingeben: double entfernungMessung() {

int dauer; // Laufzeit des Schalls in Mikrosek.


delay(2);



digitalWrite(trigger, LOW); // Burststart

dauer= pulseIn(echo, HIGH); // Laufzeit in Mikrosek.

return dauer*0.0344/2; // Rückgabe der Entfernung in cm

}

Vor dem Funktionsnamen steht der Datentyp double des Ergebnisses. In der Klammer nach dem Funktionsnamen stehen die Variablen für den Echo-Pin und für den Trigger-Pin. In der letzten Zeile der Funktion wird mit

return (dauer/2)*0.0344;

die Entfernung in cm zurückgegeben. Für die Funktion zur Ausgabe einer Entfernung können wir eingeben: void ausgabeEntfernung(double entfernung){


{


}

else

{




}

}

Diese Funktion hat keinen Ergebniswert, deshalb ist der Typ void. Damit die Funktion weiß, was sie ausgeben soll, wird ihr die Variable entfernung übergeben, wie es in der Klammer nach dem Funktionsnamen steht.


15.07.18 60

Aufgabe 3: Mögliches Programm in Kurzversion // Servo-Ansteuerung mit Servo-Bibliothek

#include <Servo.h>





double entfernungMessung() {



delay(2);




dauer = pulseIn(echo, HIGH); // Laufzeit in Mikrosek.

return dauer*0.0344/2; // Rückgabe der Entfernung in cm

}

void ausgabeEntfernung(double entfernung){


{


}

else

{




}

}

void setup() {




Serial.begin(9600);

}


15.07.18 61

void loop() {

double entfernung; // Entfernung in cm zum Objekt

servoSFZ.write(0);

entfernung = entfernungMessung();

ausgabeEntfernung(entfernung);

delay(3000);

servoSFZ.write(90);



delay(3000);

servoSFZ.write(180);



delay(3000);

}


15.07.18 62

10 Steuerung eines autonomen Roboters Im Folgenden werden verschiedene Steuerungen und Sensormessungen in einem autonomen Roboter eingesetzt. Der Roboterbausatz ist von Banggood.com. Er enthält einen Arduino UNO, ein Arduino Sensor Shield V 5.0, zwei Gleichstrommotoren mit Rädern, einen Ultraschallentfernungsmesser HC-SR04, einen Micro Servo 9g, ein Batteriefach für vier AA Batterien. Die Kosten für den Bausatz betragen etwa 20 Euro. Da für den Zusammenbau keine Anleitung beigefügt ist, sind wir auf verschiedene YouTube-Filme angewiesen. Wir haben vor allem Anregungen aus den YouTube-Filmen2 von Werner Cappel aufgenommen. Hierbei sind auch einige Halterungen mit dem 3D-Drucker erstellt worden. Der Roboter kann auch ohne die Verwendung von Bauteilen aus dem 3D-Druck zusammengebaut werden.

2 http://meinelektronikhobby.blogspot.com/2017/07/hindernislaufer-3-rad-roboter-mit.html


15.07.18 63

Mögliche Schritte beim Zusammenbau des Roboters 1. Einbau der beiden Elektromotoren auf der Trägerplatte

2. Befestigung des Stützrades mit Abstandshaltern aus dem Bausatz


15.07.18 64

3. L298N-Treibermodul auf der Unterseite der Trägerplatte mit 10-mm-Abstandshaltern, die mit einem 3D-Drucker hergestellt werden können, montieren. Evtl. vier Löcher (Durchmesser 3 mm) bohren. Befestigung mit 4 Schrauben 3 x 20 mm aus dem Baumarkt.

4. Befestigung des AA-Batteriefachs auf der Oberseite


15.07.18 65

5. Elektromotoren am Treibermodul anschließen. Die AA-Batterien über den Ein-Aus-Schalter ebenfalls am Treibermodul anschließen.

6. Arduino mit aufgesetztem Sensor Shield V 5.0 auf der Trägerplatte mit 10-mm-

Abstandshaltern befestigen.


15.07.18 66

7. Entfernungsmesser auf dem Servo befestigen und die Anschlüsse mit dem Arduino verbinden.


15.07.18 67

11 Test der einzelnen Komponenten des autonomen Roboters Servo Die Drehrichtung des Servos liegt zwischen 0° und 180°. Damit zeigt der Servo bei 90° in Fahrtrichtung. Bei 0° kann der Servo nach links oder nach recht gedreht werden. Dies kann mit folgenden Programmzeilen überprüft werden. // Servo-Bibliothek

#include <Servo.h>


Servo servoSFZ; // Servo-Objekt festlegen

void setup() {


Serial.begin(9600);

}

void loop() {

// Servo wird erneut nach vorne eingestellt

servoSFZ.write(90); // servo auf gerade aus

Serial.println("Servo gerade aus");

delay(5000);

servoSFZ.write(180); // servo auf links

Serial.println("Servo links gerichtet");

delay(5000);

servoSFZ.write(0); // servo auf links

Serial.println("Servo rechts gerichtet");

delay(5000);

}

Entfernungsmesser Die Entfernung in die Richtungen nach vorne, nach links und nach rechts sollen kontrolliert werden. Dazu kann jeweils ein Buch davor gehalten werden. // Servo-Bibliothek

#include <Servo.h>





int w_v = 90; // Winkelstellung des Servo in Vorwärtsrichtung


15.07.18 68

int w_r = 0; // Winkelstellung des Servo nach rechts

int w_l = 180; // Winkelstellung des Servo nach links




delay(2);




dauer= pulseIn(echo, HIGH);

return dauer*0.0344/2; // Rueckgabe der Entfernung in cm

}

void ausgabeEntfernung(double entfernung, int w){


{


}

else

{

Serial.print("Entfernung ");

if (w == w_v) {

Serial.print("nach vorne = ");

}

if (w == w_r) {

Serial.print("nach rechts = ");

}

if (w == w_l) {

Serial.print("nach links = ");

}



}

}

void setup() {


servoSFZ.write(w_v); // Servo nach vorne ausgerichtet



Serial.begin(9600);

}


15.07.18 69

void loop() {

double e; // Entfernung in cm zum Objekt

// Servo wird erneut nach vorne eingestellt

servoSFZ.write(w_v); // Servo nach vorne ausgerichtet

e = entfernungMessung();

ausgabeEntfernung(e, w_v);

delay(10000);

servoSFZ.write(w_l); // Servo auf links


ausgabeEntfernung(e, w_l);

delay(10000);

servoSFZ.write(w_r); // Servo auf rechts


ausgabeEntfernung(e, w_r);

delay(10000);

}

Roboter vorwärts fahren Beide Räder müssen sich vorwärts drehen. int IN1 = 11;

int IN2 = 10;

int IN3 = 9;

int IN4 = 8;

void stoppMotoren(void) {

// beide Motoren stoppen





}

void vorwaertsRoboter(int ms) {

// Roboter vorwaerts laufen lassen

digitalWrite(IN1, LOW); // rechtes Rad vorwärts


digitalWrite(IN3, LOW); // linkes Rad vorwärts


delay(ms);

}


15.07.18 70

void setup() {





}

void loop() {

stoppMotoren();

delay(1000);

vorwaertsRoboter(5000); // 1 ms vorwaerts fahren

}

Roboter rechts drehen Das linke Rad dreht sich vorwärts und das rechte Rad rückwärts. int IN1 = 11;

int IN2 = 10;

int IN3 = 9;

int IN4 = 8;

void stoppMotoren() {






}

void rechtsDrehenRoboter(int ms) {

// Roboter 90° rechts drehen

digitalWrite(IN1, LOW); // rechtes Rad rückwärts


digitalWrite(IN3, HIGH); // linkes Rad vorwärts


delay(ms);

}

void setup() {





}


15.07.18 71

void loop() {

stoppMotoren();

delay(1000);

rechtsDrehenRoboter(250); // 250 ms lang Räder gegenläufig

}

Roboter links drehen Das linke Rad dreht sich rückwärts und das rechte Rad vorwärts. int IN1 = 11;

int IN2 = 10;

int IN3 = 9;

int IN4 = 8;







}

void linksDrehenRoboter(int ms) {


digitalWrite(IN1, HIGH); // rechtes Rad vorwärts


digitalWrite(IN3, LOW); // linkes Rad rückwärts


delay(ms);

}

void setup() {





}

void loop() {

stoppMotoren();

delay(1000);

linksDrehenRoboter(250); // 250 ms lang Räder gegenläufig

}


15.07.18 72

Roboter macht eine Kehrtwende Der Roboter macht dabei eine doppelte Rechtsdrehung oder eine doppelte Linksdrehung. int IN1 = 11;

int IN2 = 10;

int IN3 = 9;

int IN4 = 8;







}

void umkehrenRoboter(int ms) {

// Roboter umdrehen





delay(ms);

}

void setup() {





}

void loop() {

stoppMotoren();

delay(1000);

umkehrenRoboter(480);

}


15.07.18 73

Programmbeispiel für den Einsatz des autonomen Roboters. Wir können für die Inbetriebnahme des autonomen Roboters viele Teile bereits erstellter Programme verwenden. Struktur des Programms:


15.07.18 74

Lösungsvorschlag

// Servo-Bibliothek

#include <Servo.h>





double min = 20; // minimaler Abstand in cm zum Hindernis

int IN1 = 11;

int IN2 = 10;

int IN3 = 9;

int IN4 = 8;







}

void rechtsDrehenRoboter(int ms) {






delay(ms);

}

void linksDrehenRoboter(int ms) {

// Roboter 90° links drehen

digitalWrite(IN1, HIGH); // rechtes Rad vorwärts


digitalWrite(IN3, LOW); // linkes Rad rückwärts


delay(ms);

}

void umkehrenRoboter(int ms) {

// Roboter umdrehen





delay(ms);

}



15.07.18 75

int dauer; // Laufzeit des Schalls in Mikrosekungen


delay(2);




dauer= pulseIn(echo, HIGH);

return dauer*0.0344/2; // Rueckgabe der Entfernung in cm

}

void vorwaertsRoboter(int ms) {

// Roboter vorwaerts laufen lassen

digitalWrite(IN1, LOW); // rechtes Rad vorwärts


digitalWrite(IN3, LOW); // linkes Rad vorwärts


delay(ms);

}

void setup() {






servoSFZ.write(90); // Servo auf gerade aus



}

void loop() {

double e; // Entfernung in cm zum Objekt


delay(10);

if (e > 300 || e < 2)

{

stoppMotoren();

}

else

{

if (e > min)

{

vorwaertsRoboter(1); // 1 ms vorwaerts fahren

}

else

{

stoppMotoren();

servoSFZ.write(0); // Servo links drehen


delay(10);


15.07.18 76

if (e > min)

{

linksDrehenRoboter(250);

}

else

{

servoSFZ.write(180); // Servo rechts drehen


delay(10);

if (e > min) {

rechtsDrehenRoboter(250);

}

else {

umkehrenRoboter(480);

}

}

servoSFZ.write(90); // Servo auf gerade aus

}

}

}


15.07.18 77

12 Arduino-Glossar Hier wird das in Vorbereitung befindliche Glossar eingefügt.

Arduino - bscw.sfz-bw.debscw.sfz-bw.de/pub/bscw.cgi/S5b4d6898/d329697/Arduino-Skript.pdf · ARDUINO...

Documents

Transcript of Arduino - bscw.sfz-bw.debscw.sfz-bw.de/pub/bscw.cgi/S5b4d6898/d329697/Arduino-Skript.pdf · ARDUINO...