Mach was mit Arduino! Einsteigen und durchstarten mit Drum Machine, Roboterauto & Co.

 

mach was mit arduino

Du bist im Besitz eines Arduino und kannst es kaum erwarten, den smarten Mikrocontroller in Aktion zu sehen? In diesem Buch erwartet dich Praxis pur. Anhand zahlreicher Beispielanwendungen lernst du alles, was du wissen musst, um deine Elektronik-Projekte mithilfe des Arduino erfolgreich in die Tat umzusetzen – von der Sketch-Programmierung über den Schaltungsaufbau bis zum Einsatz der Hardware-Komponenten.

Folgende Themen erwarten dich:

– Installation der Arduino-Software (IDE), Übertragung von Sketches
– Basics der Sketch-Programmierung: Variablen, Arrays, Schleifen & Co.
– Alles Wissenswerte zum Arduino-Board & anderen Hardware-Komponenten: Taster, LEDs, Transistoren, Sensoren, Motoren, Displays & Co.
– Elektrotechnische Grundlagen, Schaltungsaufbau (Breadboarding) & Schaltplanentwicklung mit Fritzing
– Internet der Dinge (IoT) mit Arduino & Particle Photon
– Mit zahlreichen Projekten: Weltzeituhr, Wetterstation, temperaturgeregelter Lüfter, Pflanzenbewässerungsanlage, Sythesizer & Drum Machine, Roboterauto & humanoider Roboter
– Im Internet: Die Sketches sämtlicher Beispielprojekte aus dem Buch

Wenn du darauf brennst, deine eigenen Elektronik-Projekte mit dem Arduino zu verwirklichen, dann liefert dir dieses Buch alle Skills, um den Umgang mit der Arduino-Software und -Hardware souverän zu meistern. Von leicht bis anspruchsvoll ist für jedes Wissenslevel ein Projekt enthalten, sodass deinem Erfindergeist bald keine Grenzen mehr gesetzt sein werden.

Du bist auf der Suche nach den Sketches? Hier kannst du bald die Sketches herunterladen:

2.3 Die Entwicklungsumgebung starten und den ersten Sketch übertragen

1 void setup() { // wird einmal zu Beginn ausgeführt

2}

3 void loop() { // wird endlos (also immer wieder) ausgeführt

4}

 

3.6 Wir tasten uns heran: Eine LED per Taster steuern (Teil 1)

1 int LED=9;

2 int TASTER=4;

3

4

5 void setup() {

6 pinMode(LED,OUTPUT);

7 pinMode(TASTER, INPUT);

8 digitalWrite(TASTER,HIGH);

9

10 }

11

12 void loop() {

13

14 if(digitalRead(TASTER)) digitalWrite(LED,HIGH); else

15 digitalWrite(LED,LOW);

16

1 }

 

3.9 Ein Taster, zwei Wirkungen: Eine LED ein- und ausschalten

1 int LED=9;

2 LED=9;

2 int TASTER=4;

3 int TOGGLE=false;

4 void setup() {

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

6 pinMode(LED,OUTPUT);

7 pinMode(TASTER, INPUT);

8 digitalWrite(TASTER,HIGH);

9 }

10

11 void loop() {

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

13 if(!digitalRead(TASTER)){

14 delay(100); // Entprellen des Tasters

15 If((!digitalRead(TASTER)) TOGGLE=!TOGGLE;}

16 if (TOOGLE==true) digitalWrite(LED,HIGH); else

digitalWrite(LED,LOW);

17 }

 

5.1 Die Ampel zeigt grün für den Arduino: eine Tagschaltung programmieren

1 // Einfache Ampelsteuerung

2 // Zuordnung der Digitalpins fuer die LEDS

3 int LED_Gruen=2;

4 int LED_Gelb=3;

5 int LED_Rot=4;

6

7 // Schaltzeiten

8 int Gruen_Sekunden=7;

9 int Rot_Sekunden=7;

10 int Gelb_Sekunden=3;

11

12 void setup() {

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

14 pinMode(LED_Gruen,OUTPUT);

15 pinMode(LED_Gelb,OUTPUT);

16 pinMode(LED_Rot,OUTPUT);

17

18 digitalWrite(LED_Gruen,LOW);

19 digitalWrite(LED_Gelb,LOW);

20 digitalWrite(LED_Rot,LOW);

21

22 }

23

24 void loop() {

25

26 // Grünphase

27 digitalWrite(LED_Gruen,HIGH);

28 digitalWrite(LED_Gelb,LOW);

29 digitalWrite(LED_Rot,LOW);

30 delay(1000*Gruen_Sekunden);

31

32 // Gelbphase

33 digitalWrite(LED_Gruen,LOW);

34 digitalWrite(LED_Gelb,HIGH);

35 digitalWrite(LED_Rot,LOW);

36 delay(1000*Gelb_Sekunden);

37

38 // Rotphase

39 digitalWrite(LED_Gruen,LOW);

40 digitalWrite(LED_Gelb,LOW);

41 digitalWrite(LED_Rot,HIGH);

42 delay(1000*Rot_Sekunden);

43

44 // Gelb-Rot-Phase

45 digitalWrite(LED_Gruen,LOW);

46 digitalWrite(LED_Gelb,HIGH);

47 digitalWrite(LED_Rot,HIGH);

48 delay(1000*Gelb_Sekunden);

49 }

 

5.4 Ein Spannungsteiler in Aktion: Messdaten mit einem Analog- Digital-Wandler auslesen

1 int LED_Gruen=2;

2 int LED_Gelb=3;

3 int LED_Rot=4;

4

5 int Gruen_Sekunden=5;

6 int Rot_Sekunden=5;

7 int Gelb_Sekunden=2;

8

9 int Nachtblink_Sekunden=1;

10 int LDR=0;

11

12 int Threshold=1000; // Schwellwert fürs Umschalten 0

13 bis 1024

14

15 void setup() {

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

17 pinMode(LED_Gruen,OUTPUT);

18 pinMode(LED_Gelb,OUTPUT);

19 pinMode(LED_Rot,OUTPUT);

20

21 digitalWrite(LED_Gruen,LOW);

22 digitalWrite(LED_Gelb,LOW);

23 digitalWrite(LED_Rot,LOW);

24

25 }

26

27 void loop() {

28

29

30 if(analogRead(LDR)>Threshold){ // Tagschaltung

31 // Grünphase

32 digitalWrite(LED_Gruen,HIGH);

33 digitalWrite(LED_Gelb,LOW);

34 digitalWrite(LED_Rot,LOW);

35 delay(1000*Gruen_Sekunden);

36

37 // Gelbphase

38 digitalWrite(LED_Gruen,LOW);

39 digitalWrite(LED_Gelb,HIGH);

40 digitalWrite(LED_Rot,LOW);

41 delay(1000*Gelb_Sekunden);

42

43 // Rotphase

44 digitalWrite(LED_Gruen,LOW);

45 digitalWrite(LED_Gelb,LOW);

46 digitalWrite(LED_Rot,HIGH);

47 delay(1000*Rot_Sekunden);

48

49 // Gelb-rRot-pPhase

50 digitalWrite(LED_Gruen,LOW);

51 digitalWrite(LED_Gelb,HIGH);

52 digitalWrite(LED_Rot,HIGH);

53 delay(1000*Gelb_Sekunden);

54 }

55 else {// Nachtschaltung

56

57 digitalWrite(LED_Gruen,LOW);

58 digitalWrite(LED_Gelb,LOW);

59 digitalWrite(LED_Rot,LOW);

60 delay(1000*Nachtblink_Sekunden);

61 digitalWrite(LED_Gruen,LOW);

62 digitalWrite(LED_Gelb,HIGH);

63 digitalWrite(LED_Rot,LOW);

64 delay(1000*Nachtblink_Sekunden);

65 }

66 }

 

6.2 Text auf dem Display darstellen

1 // Testsketch für LCD-Display

2 #include <LiquidCrystal.h>

3 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

4 void setup() {

5 // LCD mit 16 Spalten und zwei Zeilen initialisieren

6 lcd.begin(16, 2);

7 // Text ausgeben

8 lcd.print(„Hallo Welt!“);

9 }

10 void loop() {

11 // Cursor in der zweiten Zeile an erster Stelle

12 positionieren

13 lcd.setCursor(0, 1);

14 // Gib die Anzahl der Sekunden seit dem letzten Reset

15 aus:

16 lcd.print(millis()/1000);

17 }

 

6.3 Strings oder Rechnen mit Wörtern: Der Arduino als Digitaluhr (Teil 1)

1 String Teil1=“Hallo“;

2 String Teil2=“Welt!“;

3 lcd.print(Teil1+“  „+Teil2);

 

6.4 Was schlägt die Stunde? Der Arduino als Digitaluhr (Teil 2)

1 // Arduino als Digitaluhr mit dem LCD-Display

2

3 #include <LiquidCrystal.h

4

5 String number_to_string( long secs, int DIV, int MOD){

6 // Rechnet die Sekundenzahl um und wandelt das Ergebnis

7 // in einen String

8 // DIV=3600: Rechnet Sekunden in Stunden um

9 // DIV=60: Rechnet Sekunden in Minuten um

10 // Der Wert MOD gibt an, ab welcher Zahl die Anzeige

11 // wieder auf Null springt

12 // (Normalerweise 12 oder 24 beim Stundenzähler, 60 bei //Minuten und Sekunden

13

14 String Str;

15 unsigned long number=secs/DIV%MOD;

16

17 // Bei einstelliger Zahl noch eine Null voranstellen,

18 // sonst direkt umwandeln

19 if(number<10) Str=’0’+String(number);

20 else Str=String(number);

21 return Str;

22 }

23

24 String timeString(unsigned long secs){

25 // Wandelt die Sekundenzahl secs um in einen String im

26 // Uhrzeit-Format

27 return

28 number_to_string(secs,60*60,24)+‘:’+number_to_string(secs,60,60)+‘:’+

29 }

30

31 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

32

33 // Unter diesem Kommentar die aktuelle Uhrzeit einsetzen

34 .

35 // Die Variable Offset ist die Anzahl der Sekunden von 0

36 // Uhr bis zum gegenwärtigen Zeitpunkt.

37 // Sie wird zu den Sekunden seit Start addiert. Dadurch

38 // zeigt der Arduino beim Start nicht 0:00:00 an, sondern// Uhrzeit, die hier definiert wird:

39

40 // — — — — — — — — — — -UHRZEIT EINSETZEN– — — — — –

41 long init_stunde=17; long init_minute=35; long init_sekunde= 0;

42 // — — — — — — — — — — — — — — — — — — — — — — — — —

43 unsigned long Offset=init_stunde*3600+init_minute*60+init_sekunde;

44

45

46 void setup() {

47 // LCD mit 16 Spalten und 2 Zeilen initialisieren

48 lcd.begin(16, 2);

49 // Text für erste Zeile ausgeben

50 lcd.print(“Hamburg”);

51 }

52

53 void loop() {

54 // Anzahl Sekunden seit dem letztem Reset berechnen

55 unsigned long secs=millis() /1000 ;

56

57 // Die mit der Funktion timeString aus den Sekunden und

58 // der Startzeit berechnete Uhrzeit ausgeben

59 lcd.setCursor(0, 1);

60 lcd.print(timeString(secs+Offset));

61 }

 

6.9 Arrays – die virtuellen Sortimentskästen: Der Arduino als Weltzeituhr (Teil 2)

In der vorangegangen Codezeile haben wir ein Array mit vier Elementen definiert. Nun weisen wir den Sortimentskästen ein paar Werte zu:

Sortimentskasten[0]=“Widerstände“;

Sortimentskasten[1]=“Jumperkabel“;

Du kannst überall im Code auf die einzelnen Fächer zugreifen – zum Beispiel mit einer Abfrage:

if (Sortimentskasten[0]!=“Widerstände“) lcd.print(„Keine Widerstände gefunden.“);

 

6.10 New York, Rio, Tokyo: Der Arduino als Weltzeituhr (Teil 3)

1 int const LocNr=6;

2 String Locations[LocNr] = {„Berlin“, „Moskau“,“Los

3 Angeles“,“New York“,“Rio“,“Tokyo“};

4 unsigned long TimeShifts[LocNr] = {0,1,-9,- 7,-6,7};

5 int currentLoc;

 

/

 

1 // Taster abfragen mit Entprellung 200 ms

2 if(!digitalRead(TASTER)){

3 // Taster gedrückt, schon mal Display löschen

4 lcd.setCursor(0,0);

5 lcd.print(„ „);

6 delay(200);

7 if(!digitalRead(TASTER)){

8 // Taster nach 200 ms immer noch gedrückt,

9 weiterschalten und Stadtnamen im Display ausgeben

10 currentLoc=(currentLoc+1)%LocNr;

11 lcd.setCursor(0,0);

12 lcd.print(Locations[currentLoc]);

13 }

14

 

6.11 Jetzt wird der Arduino laut: Weltzeituhr mit Alarmfunktion

1 void alarm(){

2 for(int i=0;i<3;i++){

3 tone(BUZZER,500);

4 delay(1000);

5 tone(BUZZER,700);

6 delay(1000);

7 noTone(BUZZER);}

8 }

Alarmfunktion

 1 // Arduino als Weltzeituhr mit Alarmfunktion

2 #include <LiquidCrystal.h>

3

4 // Definitionsblock

5 int TASTER = 7;

6 int BUZZER= 8;

7

8 int const LocNr=6;

9 String Locations[LocNr] = {„Berlin“, „Moskau“,“Los Angeles“,“New York“,“Rio“

10 unsigned long TimeShifts[LocNr] = {0,1,-9,- 7,-6,7};

11 int currentLoc;

12

13 ///////////////////////////////////////////////////////////

14 // HIER DIE STARTUHRZEIT EINTRAGEN!

15 long init_stunde=13; long init_minute=55; long init_sekunde= 0;

16 unsigned long Offset=init_stunde*3600+init_minute*60+init_sekunde;

17 ///////////////////////////////////////////////////////////

18

19///////////////////////////////////////////////////////////

20 // HIER DIE ALARMUHRZEIT EINTRAGEN!

21 long alarm_stunde=13; long alarm_minute=55; long alarm_sekunde= 30;

22 unsigned long Alarm=alarm_stunde*3600+alarm_minute*60+alarm_sekunde;

23///////////////////////////////////////////////////////////

24

25 // Hilfsfunktionen

26

27 String number_to_string( long secs, int DIV, int MOD){

28 // Wandelt Sekundenzahl in String um, der Stunden, Minuten oder

29 // Sekunden angibt

30 // DIV=3600: Sekunden in Stunden

31 // DIV=60: Sekunden in Minuten

32 // MOD gibt an, ab welcher Zahl die Anzeige wieder auf Null

33 // springt (24 bei Stunden, 60 bei Minuten und Sekunden)

34

35 String Str;

36 unsigned long number=secs/DIV%MOD;

37 // Bei einstelliger Zahl noch eine Null voranstellen, sonst

38 // direkt umwandeln

39 if(number<10) Str=’0’+String(number);

40 else Str=String(number);

41 return Str;

42 }

43

44 String timeString(unsigned long secs){

45 // Wandelt die Sekundenzahl secs um in einen String im Uhrzeit-Format

46 return

47 number_to_string(secs,60*60,24)+‘:’+number_to_string(secs,6 0,60)+‘:’+number_

48 }

49

50

51

52 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

53

54

55 void alarm(){

56 for(int i=0;i<3;i++){

57 tone(BUZZER,500);

58 delay(1000);

59 tone(BUZZER,700);

60 delay(1000);

61 noTone(BUZZER);}

62 }

63

64

65 void setup() {

66 // Pinmodes setzen

67 pinMode(TASTER, INPUT);

68 digitalWrite(TASTER,HIGH);

69 pinMode(BUZZER,OUTPUT);

70 // Erste Aangezeigte Stadt wählen

71 currentLoc=0;

72 // LCD mit 16 Spalten und 2 Zeilen initialisieren

73 lcd.begin(16, 2);

74 // Text für erste Zeile ausgeben

75 lcd.print(Locations[currentLoc]);

76

77 }

78

79 void loop() {

80 // Anzahl Sekunden seit dem letztem Reset berechnen

81 unsigned long secs=millis() /1000 ;

82 unsigned long displayTime=secs+Offset+3600*TimeShifts[currentLoc];

83

84

85 lcd.setCursor(0,0);

86 lcd.print(Locations[currentLoc]);

87

88 lcd.setCursor(0, 1);

89 lcd.print(timeString(displayTime));

90 // Test auf Alarm und gegebenenfalls auslösen

91 if(displayTime==Alarm){

92 lcd.setCursor(0,0);

93 lcd.print(„ALARM „);

94 alarm();

95 }

96

97 // Taster abfragen mit Entprellung 200 ms

98 if(!digitalRead(TASTER)){

99 // Taster gedrückt, schon mal Display löschen

100 lcd.setCursor(0,0);

101 lcd.print(“ „);

102 delay(200);

103 if(!digitalRead(TASTER)){

104 // Taster nach 200 ms immer noch gedrückt, weiterschalten

105 // und Stadtnamen im Display ausgeben

106 currentLoc=(currentLoc+1)%LocNr;

107 lcd.setCursor(0,0);

108 lcd.print(Locations[currentLoc]);

109 }

110 };

111 }

 

7.2 Serielle Info für die Fehlersuche: Einsatz des seriellen Monitors

1 void setup() {

2 // Serielle Verbindung öffnen über USB Port mit 9600 baud

3 Serial.begin(9600);

4 }

5 void loop() {

6 // Ausgabe der Sekunden seit reset

7 long secs=millis()/1000;

8 Serial.print(String(secs));

9 Serial.print(„\tSekunden\n“);

10 delay(1000);

11 }

 

7.3 Jetzt kann das Wetter kommen! Aufbau der Wetterstation

1 #include <LiquidCrystal.h>

2 #include <DHT.h>

3

4 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

5 dht DHT;

6

7 int DHT11_PIN =8;

8 int Init_Delay = 1000;

9

10 int chk;

11

12 // Hilfsfunktion, um das Display zu löschen

13 void clean_lcd() {

14 lcd.setCursor(0, 0);

15 lcd.print(“ „);

16 lcd.setCursor(0, 1);

17 lcd.print(“ „);

18 }

19

20

21

22 void setup() {

23

24

25 Serial.begin(9600);

26 Serial.println(„DHT TEST PROGRAM „);

27 Serial.print(„LIBRARY VERSION: „);

28 Serial.println(DHT_LIB_VERSION);

29 Serial.println();

30

31 lcd.begin(16, 2);

32 chk = DHT.read11(DHT11_PIN);

33 lcd.setCursor(0, 1);

34 switch (chk)

35 {

36 case DHTLIB_OK:

37 lcd.print(„Status: OK“);

38 break;

39 case DHTLIB_ERROR_CHECKSUM:

40 lcd.print(„Status: Checksum error“);

41 break;

42 case DHTLIB_ERROR_TIMEOUT:

43 lcd.print(„Status: Time out error“);

44 break;

45 default:

46 lcd.print(„Status: unbekannter Fehler“);

47 break;

48 }

49 delay(Init_Delay);

50 }

51

52

53

54 void loop()

55 {

56

57

58 // Daten für den DHT11 Sensor lesen

59 chk = DHT.read11(DHT11_PIN);

60 clean_lcd();

61 lcd.setCursor(0,0);

62 lcd.print(„Type: DHT11“);

63 clean_lcd();

64 lcd.setCursor(0,0);

65 lcd.print(„Temp: „+String(DHT.temperature)+“ C“);

66

67 lcd.setCursor(0,1);

68 lcd.print(„Luftf: „+String(DHT.humidity)+“ %“);

69 delay(1000);

70

71 // Ausgabe der Daten über die serielle Schnittstelle

72 Serial.print(„relative Luftfeuchtigkeit (%): „);

73 Serial.print(DHT.humidity, 1);

74 Serial.print(„,\tTemperatur (C)“);

75 Serial.println(DHT.temperature, 1);

76 }

 

7.9 Das Potentiometer: Dateneingabe auf analoge Weise

1 #include <LiquidCrystal.h>

2

3 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

4

5 int Poti=0;

6

7 void setup() {

8 lcd.begin(16, 2);

9 }

10

11 void loop()

12 {

13 lcd.setCursor(0,0);

14 lcd.print(„Poti: „+String(analogRead(Poti))+“       „);

10 }

 

7.10 Der Servo Motor: Arme und Beine für den Arduino

Das Servo Objekt wird wie folgt erzeugt und initialisiert:

1 int Servo_Pin=9;

2 Servo myServo;

3

4 void setup() {

5 myServo.attach(Servo_Pin);

6 }

Im Beispiel haben wir den Servo an Pin 9 angeschlossen. Dies ist der Sketch zum Testen des Servos:

1 #include <Servo.h>

2 #include <LiquidCrystal.h>

3

4 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

5

6 int Poti=0;

7 int Servo_Pin=9;

8 Servo myServo;

9

10

11 void setup() {

12 // Servo Steuerpin an D9

13 myServo.attach(Servo_Pin);

14

15 lcd.begin(16, 2);

16 }

17

18 void loop()

19 {

20 lcd.setCursor(0,0);

21 // Analogwert in Gradzahl von 0 bis 180

22 // umrechnen

23 int grad=analogRead(Poti)/1024.*180;

24

25 lcd.print(„Poti: „+String(grad)+“ „);

26 myServo.write(grad);

27 }

 

7.12 Das Thermometer ist fertig: Berechnung der Temperaturskala

1 // Analoge Temperaturanzeige für die Wetterstation

2 #include <LiquidCrystal.h>

3 #include <DHT.h>

4 #include <Servo.h>

5 LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

6 dht DHT;

7 Servo myServo;

8 int DHT11_PIN =8;

9 int Servo_Pin=9;

10 int Init_Delay = 1000;

11 int Poti=0;

12 int chk;

13 // Hilfsfunktion, um das Display zu löschen

14 void clean_lcd() {

15 lcd.setCursor(0, 0);

16 lcd.print(“ „);

17 lcd.setCursor(0, 1);

18 lcd.print(“ „);

19 }

20 void setup() {

21 Serial.begin(9600);

22 Serial.println(„DHT TEST PROGRAM „);

23 Serial.print(„LIBRARY VERSION: „);

24 Serial.println(DHT_LIB_VERSION);

25 Serial.println();

26 // Servo an Pin anbinden

27 myServo.attach(Servo_Pin);

28 lcd.begin(16, 2);

29 chk = DHT.read11(DHT11_PIN);

30 lcd.setCursor(0, 1);

31 switch (chk)

32 {

33 case DHTLIB_OK:

34 lcd.print(„Status: OK“);

35 break;

36 case DHTLIB_ERROR_CHECKSUM:

37 lcd.print(„Status: Checksum error“);

38 break;

39 case DHTLIB_ERROR_TIMEOUT:

40 lcd.print(„Status: Time out error“);

41 break;

42 default:

43 lcd.print(„Status: unbekannter Fehler“);

44 break;

45 }

46 delay(Init_Delay);

47 }

48 void loop()

49 {

50 // Daten für den DHT11-Sensor lesen

51 chk = DHT.read11(DHT11_PIN);

52 clean_lcd();

53 lcd.setCursor(0,0);

54 lcd.print(„Type: DHT11“);

55 float Temp=DHT.temperature;

56 clean_lcd();

57 lcd.setCursor(0,0);

58 lcd.print(„Temp: „+String(Temp)+“ C“);

59 lcd.setCursor(0,1);

60 lcd.print(„Luftf: „+String(DHT.humidity));

61 // Temperatur umrechnen in Winkel zwischen 0 und 180 Grad

62 // Untergrenze 20 Grad Celsius entspricht 0 Winkelgrad

63 und Obergrenze 30 Grad Celsius entspricht 180 Winkelgrad

64 // Werte könne bei Bedarf angepasst werden

65 int Untergrenze=20;

66 int Obergrenze=30;

67 int Servo_Winkel= 180*(1-(Temp- Untergrenze)/(Obergrenze-

68 Untergrenze));

69 if (Servo_Winkel<0) Servo_Winkel=0;

70 if (Servo_Winkel>180) Servo_Winkel=180;

71 myServo.write(Servo_Winkel);

72 delay(1000);

73 // Ausgabe der Daten über die serielle Schnittstelle

74 Serial.print(„relative Luftfeuchtigkeit (%): „);

75 Serial.print(DHT.humidity, 1);

76 Serial.print(„,\tTemperatur (C)“);

77 Serial.println(DHT.temperature, 1);

78 }

 

8.3 Spannungsspitzen vermeiden: eine Diode zum Schutz des Arduino

1 // Motoransteuerung Testsketch

2 int Motor=13;

3

4 void setup() {

5 pinMode(Motor,OUTPUT);

6 digitalWrite(Motor,LOW);

7

8 }

9

10 void loop() {

11

12 digitalWrite(Motor,HIGH);

13

14 delay(10000);

15

16 digitalWrite(Motor,LOW);

17 dlay(3000);

 

8.4 Temperaturmessung mit dem TMP36-Sensor

1 // _TMP36 auslesen

2 int TMP36 = 0;

3 void setup()

4 {

5 Serial.begin(9600);

6 }

7 void loop()

8 {

9 int Sensor = analogRead(TMP36);

10 float V = Sensor * 5.0/1024.;

11 //Spannung am Sensor berechnen

12

13 float Temp = (V – 0.5) * 100 ;

14 // Temperatur aus Spannung berechnen

15

16 Serial.print(Temp); Serial.println(„ Grad C“);

17

18 delay(500);

19 }

 

8.5 Alles geregelt dank Arduino: Temperaturregelung und Lüfterschaltung verbinden

1 // Lüftersteuerung mit TMP36-Sensor

2 int TMP36 = 1; // Analoger Input-Pin für die

3 // Temperaturmessung

4 int Vent=13; // Output-Pin für den Ventilator

5

6 float EinTemp=60.0; // Einschalttemperatur

7 float AusTemp=45.0; // Ausschalttemperatur

8

9 void setup()

10 {

11 Serial.begin(9600);

12 pinMode(Vent,OUTPUT);

13

14 digitalWrite(Vent,LOW); // Ventilator aus

15

16 }

17 void loop()

18 {

19 int Sensor = analogRead(TMP36);

20

21 float V = Sensor * 5.0/1024.;

22 float Temp = (V – 0.5) * 100 ;

23

24 // Regelungsabfrage:

25 if (Temp&gt;=EinTemp) digitalWrite(Vent,HIGH);

26 if (Temp&lt;=AusTemp) digitalWrite(Vent,LOW);

27

28 Serial.print(Temp); Serial.println(„ Grad C“);

29 Serial.println(Sensor);

30

31 delay(500);

32 }

 

10.2 Aufbau und Programmierung der Pflanzenbewässerungsanlage

1 #define SensorPin A0

2 //#define ersetzt jedes Vorkommen von SensorPin durch A0.

3 //Dadurch muss bei Änderung des Pins nur A0 hier geändert werden

4

5 void setup() {

6 Serial.begin(9600);

7 pinMode(SensorPin, INPUT);

8 }

9

10 void loop() {

11 int sensorValue = analogRead(SensorPin); //Auslesen der Messwerte

12 Serial.print(„Feuchtigkeit betraegt: „);

13 Serial.print(sensorValue);

14

15 if(sensorValue >= 1000){

16 Serial.println(“ – Sensor steckt nicht im Boden oder ist nicht angeschlossen“);

17 } else if(sensorValue < 1000 &amp;&amp; sensorValue >= 600) {

18 Serial.println(“ – Boden ist trocken“);

19 } else if(sensorValue < 600 &amp;&amp; sensorValue >= 370) {

20 Serial.println(“ – Boden ist feucht“);

21 } else if(sensorValue <; 370) {

22 Serial.println(“ – Boden ist nass“);

23 }

24 delay(1000); //Wir wollen nur einmal pro Sekunde die Änderungen messen-

25 }

26 }

 

Mit diesem einfachen Setup muss keine Pflanze in unserem Büro mehr verdursten:

1 #define WasserMotor 2

2

3 void setup() {

4 …

5 pinMode(WasserMotor, OUTPUT);

6 }

7

8 void loop() {

9 …

10 if(sensorValue >= 1000){

11 Serial.println(“ – Sensor steckt nicht im Boden oder ist nicht angeschlossen“);

12 wasserPumpen(false); //beendet das Pumpen

13 } else if(sensorValue < 1000 &amp;&amp; sensorValue >= 600) {

14 Serial.println(“ – Boden ist trocken“);

15 wasserPumpen(true); //beginnt das Pumpen

16 } else if(sensorValue < 600 &amp;&amp; sensorValue >= 370) {

17 Serial.println(“ – Boden ist feucht“);

18 wasserPumpen(false);

19 } else if(sensorValue < 370) {

20 Serial.println(“ – Boden ist nass“);

21 wasserPumpen(false);

22 }

23 delay(1000);

24 }

25

26 // wasserPumpen() nimmt einen boolean entgegen. Ist dieser ‚true‘, beginnt die Pumpe zu pumpen, bei ‚false‘ stoppt sie

27 void wasserPumpen(bool pumpen){

28 if(pumpen){

29 digitalWrite(WasserMotor, HIGH);

30 Serial.println(„Bewaessert“);

31 } else {

32 digitalWrite(WasserMotor, LOW);

33 }

34 }

 

10.3 Steuerung der Pflanzenbewässerung übers Internet

1 String message = “ „;

2 boolean messageComplete = false;

3

4 void setup(){

5 …

6 message.reserve(200);

7 }

8

9 void loop(){

10 …

11 if (messageComplete){

12 // die Nachricht message ist hier nun vollständig und kann bearbeitet werden

13 message = “ „;

14 messageComplete = false;

15 }

16 }

17

18 void serialEvent(){

19 while(Serial.available()){

20 char inChar = (char)Serial.read();

21 message += inChar;

22

23 if(inChar == ‚\n‘){

24 messageComplete = true;

25 }

26 }

 

Der Inhalt der Variable ist auch über einen Aufruf der übergebenen Methode zu erreichen.

1

2

3 void setup() {

4 Serial1.begin(9600);

5 messageRx.reserve(100);

6 Particle.variable(„messageRx“, messageRx);

7 //Der Inhalt der Variable ist verfügbar unter https://api.particle.io/v1/devices/DEVICE_ID/messageRx?access_token=TOKEN_ID

8 //Die Function sendData kann aufgerufen werden unter https://api.particle.io/v1/devices/DEVICE_ID/conditions

9 Particle.function(„conditions“,sendData); //

10 }

11

12 void loop() {

13 messageRx = Serial1.readStringUntil(‚\n‘);

14 delay(10000);

15 }

16

17 void sendData(String command){

18 Serial1.println(command);

19 }

 

Im Folgenden siehst du, wie der Script-Source Code auf der Website für eine solche Operation aussehen könnte:

1 /Diese Funktion ändert den Inhalt des Fensters mit der ID ‚position‘ einmal pro Sekunde.

2 window.setInterval(function() {

3 //Die URL, an der wir die Variable vom Photon erhalten

4 requestURL = „https://api.spark.io/v1/devices/“ +deviceID + „/“ + getFunc + „/?access_token=“ +accessToken;

5 $.getJSON(requestURL, function(json) {

6 //Tauscht den Inhalt des Elements mit der ID ‚position‘ mit den Daten document.getElementById(„poition“).innerHTML = json.result;

7 });

8 }, 1000); //Ruft die Funktion alle 1000 Millisekunden auf

9

10 //Die Funktion holt sich alle Werte aus Feldern

11 function setValues() {

12 var newValue = “ „;

13 newValue += document.getElementById(’nasswertId‘).value + „:“;

14 newValue += document.getElementById(‚feuchtwertId‘).value + „:“;

15 newValue += document.getElementById(‚trockenwertId‘).value+ „:“;

16 sparkSetPos(newValue);

17 }

18

19 //Und letztendlich werden die Daten als POST an unsere Photon-Cloud- Funktion gesendet

20 function sparkSetPos(newValue) {

21 var requestURL =“https://api.spark.io/v1/devices/“ + PHOTON_ID + „/“ + FUNKTIONS_NAME + „/“;

22 $.post( requestURL, { params: newValue, access_token: accessToken });

23 }

 

Dies ist der Code für die Offline-Lösung:

1 //Arduino Offline

2 #define SensorPin A0

3 #define WasserMotor 2

4

5 void setup() {

6 Serial.begin(9600);

7 pinMode(SensorPin, INPUT);

8 pinMode(WasserMotor, OUTPUT);

9 }

10

11 void loop() {

12 int sensorValue = analogRead(SensorPin);

13 Serial.print(„Feuchtigkeit betraegt“);

14 Serial.print(sensorValue);

15

16 if(sensorValue >= 1000){

17 Serial.println(“ – Sensor steckt nicht im Boden oder ist nicht angeschlossen“);

18 } else if(sensorValue < 1000 &amp;&amp; sensorValue >= 600) {

19 Serial.println(“ – Boden ist trocken“);

20 wasserPumpen(true);

21 } else if(sensorValue <600 &amp;&amp; sensorValue >= 370) {

22 Serial.println(“ – Boden ist feucht“);

23 wasserPumpen(false);

24 } else if(sensorValue < 370) {

25 Serial.println(“ – Boden ist nass“);

26 wasserPumpen(false);

27 }

28 delay(200);

28 }

29

30 void wasserPumpen(bool pumpen){

31 if(pumpen){

32 digitalWrite(WasserMotor, HIGH);

33 Serial.println(„Bewaessert“);

34 } else {

35 digitalWrite(WasserMotor, LOW);

36 }

37 }

38

39 void sendData(){

41

42 }

 

Dies ist der Code für die Online-Lösung:

1 //Arduino Online

2

3 #define SensorPin A0

4 #define WasserMotor 2

5

6 String message = “  „;

7 boolean messageComplete = false;

8

9 int zustandTrocken = 1000;

10 int zustandFeucht = 600;

11 int zustandWasser = 370;

12

13 void setup() {

14 Serial.begin(9600);

15 pinMode(SensorPin, INPUT);

16 pinMode(WasserMotor, OUTPUT);

17

18 message.reserve(200);

19 }

20

21 void loop() {

22 int sensorValue = analogRead(SensorPin);

23 Serial.print(„Feuchtigkeit betraegt „);

24 Serial.print(sensorValue);

25

26 if(sensorValue >= zustandTrocken){

27 Serial.print(“ – Sensor steckt nicht im Boden oder ist nicht angeschlossen \n“);

28 wasserPumpen(false);

29 } else if(sensorValue < zustandTrocken &amp;&amp; sensorValue >= zustandFeucht) {

30 Serial.print(“ – Boden ist trocken“);

31 wasserPumpen(true);

32 } else if(sensorValue < zustandFeucht &amp;&amp; sensorValue >=zustandWasser) {

33 Serial.print(“ – Boden ist feucht \n“);

34 wasserPumpen(false);

35 } else if(sensorValue < zustandWasser) {

36 Serial.print(“ – Boden ist nass \n“);

37 wasserPumpen(false);

38 }

39 delay(1000);

40

41 if (messageComplete){

42 aendereZustaende(message);

43 message = “  „;

44 messageComplete = false;

45 }

46 }

47

48 void wasserPumpen(bool pumpen){

49 if(pumpen){

50 digitalWrite(WasserMotor, HIGH);

51 Serial.print(“ — > Bewaessert \n“);

55 } else {

53 digitalWrite(WasserMotor, LOW);

54 }

55 }

56

57 void aendereZustaende(String zustaende){

58 zustandWasser = splitString(zustaende, ‚:‘, 0).toInt();

59 zustandFeucht = splitString(zustaende, ‚:‘, 1).toInt();

60 zustandTrocken = splitString(zustaende, ‚:&‘, 2).toInt();

61 }

62 String splitString(String s, char parser, int index) {

63 String rs=“\0″;

64 int parserIndex = index;

65 int parserCnt=0;

66 int rFromIndex=0, rToIndex=-1;

67 while (index >= parserCnt) {

68 rFromIndex = rToIndex+1;

69 rToIndex = s.indexOf(parser,rFromIndex);

70 if (index == parserCnt) {

71 if (rToIndex == 0 || rToIndex == -1) {

72 return „\0“;

73 }

74 return s.substring(rFromIndex,rToIndex);

75 } else {

76 parserCnt++;

77 }

78 }

79 return rs;

80 }

81 void serialEvent(){

82 while(Serial.available()){

83 char inChar = (char)Serial.read();

84 message += inChar;

85

 86 if(inChar == ‚\n‘){

87 messageComplete = true;

88 }

89 }

90 }

 

Dies ist der Code für den Particle Proton:

1 //Particle Photon

2 String messageRx = „initial“;

3

4 void setup() {

5 Serial1.begin(9600);

6 messageRx.reserve(100);

7 Particle.variable(„messageRx“, messageRx);

 8Particle.function(„conditions“,setConditions);

9

10 }

11

12 void loop() {

13 receiveData();

14 }

15

16 void sendData(String command){

17 Serial1.println(command);

18 }

19

20 void receiveData(){

21 messageRx = Serial1.readStringUntil(‚\n‘);

22 delay(10000);

23 }

24

25 int setConditions(String conditions){

26 sendData(conditions);

27 return 0;

28 }

Dies ist der Code für die Website:

1 //Website

2 <!– Token: 4902ae5d9a72ac085c6b20f4ccb1bdf325a4eb7f ;

3 ID: 250038001547353236343033 — >

4 <!DOCTYPE HTML>

5 <html>

6 <script src=“http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.m in.js“ type=“text/javascript“ charset=“utf-8″></script>

7 <body>

8

9 <p>Konfiguration der Bewässerungsanlage</p>

10<P>Ändere Werte: (Standardwerte: Wasser bis 370, Feucht bis 600, Trocken bis 1000)<br><br>

11  Wert für Wasser: <input type=“text“ name=“nasswert“ id=“nasswertId“><br>

12 Wert für feucht: <input type=“text“ name=“feuchtwert“ id=“feuchtwertId“><br>

13 Wert für trocken: <input type=“text“name=“trockenwert“ id=“trockenwertId“><br>

14 <input type=“button“ id=“sendButton“ value=“Send newvalues“ onclick=“setValues()“><br>

15

16 <P>Derzeitiger Bodenzustand: <spanid=“curPos“></span><br>

17

18 <script type=“text/javascript“>

19 var deviceID = „250038001547353236343033“;

20 var accessToken =“4902ae5d9a72ac085c6b20f4ccb1bdf325a4eb7f“;

21 var setFunc = „conditions“;

22 var getFunc = „messageRx“;

23

24 window.setInterval(function() {

25 requestURL = „https://api.spark.io/v1/devices/“ +deviceID + „/“ + getFunc + „/?access_token=“ + accessToken;

26 $.getJSON(requestURL, function(json) {

27 document.getElementById(„curPos“).innerHTML = json.result;

28 });

29 }, 1000);

30

31 function setValues() {

32 var newValue = “ „;

33 newValue +=document.getElementById(’nasswertId‘).value + „:“;

34 newValue +=document.getElementById(‚feuchtwertId‘).value + „:“;

35 newValue +=document.getElementById(‚trockenwertId‘).value+ „:“;

36 sparkSetPos(newValue);

37 }

38

39 function sparkSetPos(newValue) {

40 var requestURL =“https://api.spark.io/v1/devices/“ +deviceID + „/“ +setFunc + „/“;

41 $.post( requestURL, { params: newValue,access_token: accessToken });

42 }

43 </script>

44 </body>

45 </html>

 

11.1 Ohne Sound geht nichts: Tonerzeugung mit Piezo-Summer oder Lautsprecher

1 // Arduino-Audio- Projekte: Einfaches Tonsignal

2

3 // Definitionsblock

4 int BUZZER= 7;

5

6 void alarm(){

7 for(int i=0;i<3;i++){

8 tone(BUZZER,500);

9 delay(1000);

10 tone(BUZZER,700);

11 delay(1000);

12 noTone(BUZZER);}

13

14 }

15

16 void setup() {

17 // Pinmodes setzen

18 pinMode(BUZZER,OUTPUT);

19 }

20

21 void loop() {

22 alarm();

23 delay (5000);

24 }

 

11.2 Do Re Mi Fa So La Ti: eine Tonleiter spielen

1 Note Frequenz

2 c 261 Hz

3 d 294 Hz

4 e 329 Hz

5 f 349 Hz

6 g 392 Hz

7 a 440 Hz

8 b 493 Hz

9 C 523 Hz

Wir hinterlegen also die Abkürzungen für die Töne und Frequenzen einer C-Dur Tonleiter:

1 #define c1 261

2 #define d1 294

3 #define e1 329

4 #define f1 349

5 #define g1 392

6 #define a1 440

7 #define b1 493

8 #define c2 523

9 #define P 0

 

11.3 Auf das Timing kommt es an: die Tondauer festlegen

Dies ist ein Beispiel, das du vielleicht schon mal gehört hast:

1 int melodie [ ]={e1,a1,P,a1,g1,a1,e1,P,a1,c2,P,b1,a1};

2 int dauer [ ]

3 ={300,200,300,300,300,300,200,400,300,200,300,300,400};>

Dies kannst du sinnvoll in eine eigene Funktion packen:

5 for(int i=0; i<sizeof(melodie)/2;i++){

6<

7 if (melodie[i]!=P) tone(BUZZER, melodie[i]);

8 delay(dauer[i]);

9 noTone(BUZZER);}

10 }

 

11.4 Melodiegenerator und Lautstärkeregler

1 // Arduino-Audio- Projekte: Kleine Melodie abspielen

2

3 // Frequenzen der C-Dur- Tonleiter

4 #define c1 261

5 #define d1 294

6 #define e1 329

7 #define f1 349

8 #define g1 392

9 #define a1 440

10 #define b1 493

11 #define C2 523

12 #define P 0

13

14 int BUZZER= 7;

15

16 int melodie[]={e1,a1,P,a1,g1,a1,e1,P,a1,C2,P,b1,a1};

17 int dauer[]

18 ={300,200,300,300,300,300,200,400,300,200,300,300,400};

19

20 void spiele_Melodie(){

21 for(int i=0; I<sizeof(melodie)/2;i++){

22

23 if (melodie[i]!=P) tone(BUZZER, melodie[i]);

24 delay(dauer[i]);

25 noTone(BUZZER);}

26 }

27

28 void setup() {

29 // Pinmodes setzen

30 pinMode(BUZZER,OUTPUT);

31

32 }

33

34 void loop() {

35 spiele_Melodie();

36 delay (5000);

37 }

38

 

11.6 Auf und ab: eine Melodie in allen Tonarten erklingen lassen

1 // Arduino-Audio- Projekte: Kleine Melodie abspielen mit

2 Pitch-Regler

3

4 // Frequenzen der C-Dur- Tonleiter

5 #define c1 261

6 #define d1 294

7 #define e1 329

8 #define f1 349

9 #define g1 392

10 #define a1 440

11 #define b1 493

12 #define c2 523

13 #define P 0

14

15 int BUZZER= 7;

16 int Poti=0;

18 int melodie[]={e1,a1,P,a1,g1,a1,e1,P,a1,c2,P,b1,a1};

19 int dauer[]

20 ={300,200,300,300,300,300,200,400,300,200,300,300,400};

21

22 void spiele_Melodie(float Pitch){

23 for(int i=0; I<sizeof(melodie)/2;i++){

24

25 if (melodie[i]!=P) tone(BUZZER,

26 Pitch*float(melodie[i]));

27 delay(dauer[i]);

28 noTone(BUZZER);}

29 }

30

32

33 void setup() {

33 // Pinmodes setzen

34 pinMode(BUZZER,OUTPUT);

35

36 }

37

38 void loop() {

39 float Pitch=analogRead(Poti)/256.;

40 spiele_Melodie(Pitch);

41 delay (5000);

42 }

 

13.3 Mit PORTD die digitalen Pins kontrollieren

1 // Test des D/A-Wandlers mit Multimeter

2 void setup(){

3 for (int i=0;i<8;i++){

4 pinMode(i,OUTPUT);

5 }

6 }

7 void loop(){

8 for(int i=0; i<26 ;i++)

9 {PORTD=i*10;

10 delay(3000);

11 }

12 }

 

CONTINUE