706_c_ARDUINO-x_ARDUINO UNO Rev.3 - Begrifflichkeiten (Grundlagen Wissen)_1a.xls

200 Ohm  rot    schwarz schwarz   schwarz   rot    ( 2 0 0   -   2% )

470 Ohm  gelb   violett           braun     gold   ( 4 7     0   5% )

330 Ohm  orange orange  schwarz   schwarz   rot    ( 3 3 0   0   2% )
1,00k    braun  schwarz schwarz   braun     braun  ( 1 0 0   0   1% )
10,0k    braun  schwarz schwarz   rot       braun  ( 1 0 0  00   1% )



de.wikipedia.org/wiki/Arduino-Plattform

1) Funduino UNO
http://funduino.de/index.php/shop/product/view/2/4

2) SainSmart UNO R3 Starter Kit mit 16 Basic Arduino Projekte  SKU:20-013-100*WB
http://www.sainsmart.com/sainsmart-uno-r3-starter-kit-with-16-basic-arduino-projects.html

3) Freeduino.de - Arduino Microcontroller
SB-Freeduino
https://solarbotics.com/product/28920/
http://www.freeduino.org/freeduino_open_designs.html
http://www.freeduino.de/
http://www.arduino-freeduino.de/

4) Seeeduino Mega V3.0 (Arduino kompatibel)
Seeeduino V3.0 (ATmega328P) - Arduino kompatibel
http://www.seeedstudio.com/wiki/Seeeduino_v3.0

$baud=9600  pin-0 (D0, RxD hinein) und pin-1 (D1, TxD hinaus)  sind nicht mehr verfügbar

Sketches und die manchmal dazu notwendige Library können vom Internet heruntergeladen werden.

z.B. Infrarot Fernbedienung

Der  Sektch IRremote kann zusammen mit der wichtigen IR-Remote-library von der Internetseite
https://github.com/shirriff/Arduino-IRremote
heruntergeladen werden.
Dazu klickt man auf der Seite github unten rechts auf "Download ZIP".

Den Ordner mit der gepackten Datei kopiert man in das Arduino Haupt-Verzeichnis in den Ordner
MENU > Datei > libraries > IRremote >  alle Dateien

Nun kann man den Sketch "IRrecvDemo" im Arduino-Programm unter
MENU > Datei > Beispiele > IRremote > IRrecvDemo
aufrufen.

Habe an dieser 74 Seiten ARDUINO UNO Anleitung (für Anfänger - so wie ich)
40 Stunden geschrieben und getestet.

715_d_ARDUINO-x_FunduinoUNO R3 - Lernset-3 +++ ANLEITUNG (74 Seiten)_4b.doc

Da ich alles selbst gebaut und getestet habe gehe ich davon aus
das bis auf Tippfehler alles fehlerfrei ist.

Ich habe mich bemüht alles bis ins Detail zu beschreiben.

Ein kleiner Auszug, einige Sketche davon, siehe UNTEN.

Ich möchte Sie ersuchen mich auf eventuelle Fehler aufmeksam zu machen.

Bitte aber auch den genauen Link angeben.

GRUND: ich habe tausende Links und 100.000ende Seiten in meinen diversen Sammlungen.

// Titel: 3.1 Eine blinkende LED// Beschreibung: pin-13 OnBoard LED blinkt // Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_1_Eine_blinkende_LED_1b.ino// Shield: keines// Controller: Arduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_1_Eine_blinkende_LED_1b// pin-13 OnBoard LEDorangevoid setup()              // hier beginnt das Setup{                         // hier beginnt ein Programmabschnitt  pinMode(13, OUTPUT);    // pin-13 soll ein Ausgang sein}                         // hier ist der Programmabschnitt beendetvoid loop()               // hier beginnt das Hauptprogramm{                         // Programmabschnitt beginnt  digitalWrite(13, HIGH); // schaltet die die Spannung an pin-13 ein (LED an)  delay(1000);            // warte 1000 Millisekunden (eine Sekunde)  digitalWrite(13, LOW);  // schalte die die Spannung an pin-13 aus (LED aus)  delay(500);             // warte 500 Millisekunden (eine Sekunde)}                         // am Ende springt das Programm an den Start des Hauptprogrammes





// Titel: 3.2  Der Wechselblinker// Beschreibung: LED pin-7 LED pin-8  blinkt wechselweise// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_2_Der_Wechselblinker_2c.ino// Shield: keines// Controller: Funduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_2_Der_Wechselblinker_2c// pin-7 a-LEDrot-k  100R GND// pin-8 a-LEDblau-k 200R GNDvoid setup()             // wir starten mit dem Setup{                        // hier beginnt ein Programmabschnitt  pinMode(7, OUTPUT);    // pin-7 ein Ausgang  pinMode(8, OUTPUT);    // pin-8 ein Ausgang}                        // hier ist der Programmabschnitt beendetvoid loop()              // das Hauptprogramm beginnt hier{                        // Programmabschnitt beginnt  digitalWrite(7, HIGH); // schalte die LEDrot an (pin-7 +5V)  delay(150);            // warte 0,15 Sekunden  digitalWrite(7, LOW);  // schalte die LEDrot an (pin-7  GND)  digitalWrite(8, HIGH); // schalte die LEDblau an (pin-8 auf Vcc)  delay(1850);           // warte 1,85 Sekunden.  digitalWrite(8, LOW);  // schalte die LEDblau an (pin-8 auf GND)}                        // am Ende springt das Programm an den Start des Loop-Teils

// Titel: 3.3  Gleichzeitiges Licht- und Tonsignal// Beschreibung: pin-4 blinkt und pin-5 Buzzer-Signal // Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_3_Gleichzeitiges_Licht_und_Tonsignal_1b.ino// Shield: keines// Controller: SainSmart UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_3_Gleichzeitiges_Licht_und_Tonsignal_1b

 /* Dieses Mal nutzen wir auch den ersten Programmabschnitt.  Deklarierung und Initialisierung z.B. Variablen benennen Das bedeutet, dass sich hinter einem Wort / einem Buchstaben eine Zahl verbirgt.  Damit man die Pin's nicht verwechselt, benennen wir pin-4 und pin-5 einfach um. */// pin-4 a-LEDgelb-k 100R GND // pin-5 a-Buzzer-k GNDint LED=4;                   // LED steht jetzt für die Zahl 4   int Piezo=5;                 // Piezo steht für die Zahl 5 void setup()                 // wir starten mit dem Setup{  pinMode(LED, OUTPUT);      // pin-4 ist ein Ausgang  pinMode(Piezo, OUTPUT);    // pin-5 ist ein Ausgang}void loop()                  // Hauptprogramm beginnt{  digitalWrite(LED, HIGH);   // schalte die LED an  digitalWrite(Piezo, HIGH); // schalte den Piezo-Buzzer an  delay(1000);               // warte 1 Sekunden, es piepst und leuchtet  digitalWrite(LED, LOW);    // schalte die LED aus  digitalWrite(Piezo, LOW);  // schalte den Buzzer aus  delay(4000);               // warte 4 Sekunden - kein Ton, kein Licht}                            // Programm springt an den Start des Loop-Teils/* Hier am Ende springt das Programm an den Start des Loop-Teils.  also wird es gleich wieder piepsen und leuchten.  Wenn man die Pause (delay) verkleinert oder vergrößert, piepst und leuchtet es schneller oder langsamer. */

// Titel: 3.4  Eine LED pulsieren lassen (fade)// Beschreibung: LEDgrün an pin-9 wird allmählich heller bzw. dunkler// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_4_Eine_LED_pulsieren_lassen_1b.ino// Shield: keines// Controller: Freeduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_4_Eine_LED_pulsieren_lassen_1b// pin-9 a-LEDgrün-k 100R GNDint LED=9;              // das Wort LED steht für den pin-9 int helligkeit= 0;   /* Das Wort „helligkeit“ steht nun für den Wert, der bei der PWM ausgegeben wird. Die Zahl 0 ist dabei nur ein beliebiger Startwert */int fadeschritte= 5;    /* fadeschritte: bestimmt die Geschwindigkeit des „fadens“ 1=sehr langsam 3 5 15 17=mittel 51 85 255=sehr schnell 255/16=15,9375 keine ganze Zahl geht daher nicht. */void setup()            // hier beginnt das Setup{  pinMode(LED, OUTPUT); // pin-9 mit der LEDgrün ist Ausgang}void loop()             // das Hauptprogramm beginnt{  analogWrite(LED, helligkeit);     /*mit der Funktion analogWrite wird hier an dem Pin mit der LED (pin-9)    die PWM Ausgabe aktiviert. Der PWM-Wert ist der Wert, der unter dem Namen „helligkeit“    gespeichert ist. In diesem Fall „0“ (Siehe OBEN)   */  helligkeit = helligkeit + fadeschritte;     /*nun wird der Wert für die PWM-Ausgabe verändert.    Unter dem Wert „helligkeit“ wird jetzt zur vorherigen helligkeit der Wert    für die fadeschritte addiert. In diesem Fall: helligkeit = 0 + 5.    Der neue Wert für „helligkeit“ ist also nicht mehr 0 sondern 5.    Sobald der Loop-Teil einmal durchgelaufen ist, wiederholt er sich.    Dann beträgt der Wert für die Helligkeit 10. Im nächsten Durchlauf 15 usw. usw...   */  delay(50);     /*die LED soll für 50ms die Helligkeit beibehalten,     verringert man diesen Wert, wird das Pulsieren ebenfalls schneller.   */  if (helligkeit == 0 || helligkeit == 255) {        /* Bedeutung des Befehls:      Wenn die Helligkeit den Wert 0 ODER 255 erreicht hat,      wechselt der Wert für die „fadeschritte“      von positiv zu negativ bzw. andersrum.      Grund:      Die LED wird zunächst bei jedem Durchlauf des Loop-Teils immer ein bisschen heller.      Allerdings ist irgendwann der Max.-Wert für die PWM-Ausgabe mit Wert 255 erreicht.      Die LED soll dann wieder Schritt für Schritt dunkler werden.      */    fadeschritte = -fadeschritte;       /* also wird der Wert für die „fadeschritte“ an dieser Stelle negativiert      (Ein Minuszeichen wird davor gesetzt).     Das bedeutet für den nächsten Durchlauf,      dass in der Zeile „helligkeit = helligkeit + fadeschritte;“ die helligkeit abnimmt.      Beispiel: „helligkeit=255+(-5)“. Der Wert für Helligkeit ist ab dann 250.      Im nächsten Durchlauf 245 usw. usw...      sobald der Wert für Helligkeit bei 0 angekommen ist, wechselt wieder das Vorzeichen.      Man bedenke die alte mathematische Regel:„minus und minus ergibt plus“.     */  }  // fadeschritte Prg.-Teil wird geschlossen}     // Loop-Teil wird geschlossen, und Prg. springt an den Start des Loop-Teiles

// Titel: 3.5 Zeitschalter / Stiegenhaus-Timer// Beschreibung: Taster gedrückt die LEDrot leuchtet 5 Sekunden// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_5_Eine_LED_per_Tastendruck_5sec_aktivieren_1b.ino// Shield: keines// Controller: Seeduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_5_Eine_LED_per_Tastendruck_5sec_aktivieren_1b// 5V Taster pin-6  1k  GND  (ACHTUNG: Große Pinabstände bei Taster sind verbunden)// pin-7 a-LEDrot-k  100R GNDint taster=6;                    // das Wort „taster“  steht jetzt für den Wert 6int LEDrot=7;                    // das Wort „LEDrot“ steht jetzt für den Wert 7int tasterstatus=0;/* Das Wort „tasterstatus“ steht jetzt zunächst für den Wert 0 Später wird unter dieser Variable gespeichert, ob der Taster gedrückt ist oder nicht */void setup()                     // hier beginnt das Setup{  pinMode(LEDrot, OUTPUT);       // der pin-7 mit der roten LED ist jetzt ein Ausgang  pinMode(taster, INPUT);        // der pin-6 mit dem Taster ist jetzt ein Eingang}void loop()                      // das Hauptprogramm beginnt{                                // mit dieser Klammer wird der Loop-Teil geöffnet  tasterstatus=digitalRead(taster);  /* hier wird der pin-6 ausgelesen (Befehl: digitalRead)   Das Ergebnis wird unter der Variable „tasterstatus“ mit dem Wert „HIGH“ für 5 Volt    oder „LOW“ für 0 Volt gespeichert.   Verarbeitung: Wenn der Taster gedrückt ist (Ist das Spannungssignal hoch = +5V)   */  if (tasterstatus == HIGH)      // Programmabschnitt des if-Befehls öffnen  {    digitalWrite(LEDrot, HIGH);  // dann soll die LED leuchten    delay (5000);                // und zwar für für 5 Sekunden = 5000ms    digitalWrite(LEDrot, LOW);   // danach soll die LED aus sein.  }                              // Programmabschnitt des if-Befehls schließen  else                           // ansonsten  {                              // Programmabschnitt des else-Befehls öffnen    digitalWrite(LEDrot, LOW);   // soll die LED aus sein  }                              // Programmabschnitt des else-Befehls schließen}                                // letzte Klammer schliesst den Loop-Teil

// Titel: 3.5b EIN-Taster// Beschreibung: Taster gedrückt die rote LED leuchtet// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_5b_LED_EIN_per_Tastendruck_1a.ino// Shield: keines// Controller: Arduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_5b_LED_EIN_per_Tastendruck_1a// 5V Taster pin-6  10k  GND  (ACHTUNG: Große Pinabstände bei Taster sind verbunden)// pin-7 a-LEDrot-k  200R GNDconst int taster=6;               // das Wort „taster“  steht jetzt für den Wert 6const int LEDrot=7;               // das Wort „LEDrot“ steht jetzt für den Wert 7int tasterstatus=0;               // Variablen wird sich ändern/* Das Wort „tasterstatus“ steht jetzt zunächst für den Wert 0 Später wird unter dieser Variable gespeichert, ob der Taster gedrückt ist oder nicht */void setup()                     // hier beginnt das Setup{  pinMode(LEDrot, OUTPUT);       // der pin-7 mit der roten LED ist jetzt ein Ausgang  pinMode(taster, INPUT);        // der pin-6 mit dem Taster ist jetzt ein Eingang}void loop()                      // das Hauptprogramm beginnt{                                // mit dieser Klammer wird der Loop-Teil geöffnet  tasterstatus=digitalRead(taster);  /* hier wird der pin-6 ausgelesen (Befehl: digitalRead)   Das Ergebnis wird unter der Variable „tasterstatus“ mit dem Wert „HIGH“ für 5 Volt    oder „LOW“ für 0 Volt gespeichert.   Verarbeitung: Wenn der Taster gedrückt ist (Ist das Spannungssignal hoch = +5V)   */  if (tasterstatus == HIGH)      // Programmabschnitt des if-Befehls öffnen  {    digitalWrite(LEDrot, HIGH);  // danach soll die LED aus sein.  }                              // Programmabschnitt des if-Befehls schließen  else                           // ansonsten  {                              // Programmabschnitt des else-Befehls öffnen    digitalWrite(LEDrot, LOW);   // soll die LED aus sein  }                              // Programmabschnitt des else-Befehls schließen}                                // letzte Klammer schlliesst der Loop-Teil

// Titel: 3.6  CdS Helligkeits-Sensor auslesen - Dämmerungs-Schalter// Beschreibung: Lux-Meter mit 5mm CdS Fotowiderstand GL55// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_6_CdS_HelligkeitsSensor_auslesen_mit_DaemmerungsSchalter_1b.ino// Shield: keines// Controller: Arduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_6_CdS_HelligkeitsSensor_auslesen_mit_DaemmerungsSchalter_1b// 5V  CdS  pin-A0 1k  GND  // pin-10 a-LEDweis-k  100R GNDint eingang= A0;                  // „eingang“ steht jetzt für Analog-Port 0int LED = 10;                     // das Wort „LED“ steht jetzt für den pin-10int sensorWert = 0;               // variable für den Sensor-Wert - 0 als Start-Wertvoid setup()                      // hier beginnt das Setup{  Serial.begin(9600);    /* Die Kommunikation mit dem seriellen Port wird gestartet.    Das benötigt man, um sich den tatsächlich ausgelesenen rohWert später    im "Serial-Monitor" anzeigen zu lassen.   */  pinMode (LED, OUTPUT);  /* der Pin mit der LED (pin-10) ist jetzt ein Ausgang     der analoge pin-A0 muss nicht als Eingang definiert werden   */}void loop()                        // das Hauptprogramm beginnt{                                  // mit dieser Klammer wird der Loop-Teil geöffnet  sensorWert =analogRead(eingang);   // Spannung an dem Foto-Widerstand auslesen und unter Variable „sensorWert“ abspeichern  Serial.print("Sensor-Wert = " ); // Ausgabe am Serial-Monitor: Das Wort „Sensor-Wert"  Serial.println(sensorWert);      // Serial.println  bedeutet Zeilenende (Line-Feed)  /*    Mit dem Befehl Serial.print wird der SensorWert des Foto-Widerstandes in Form einer Zahl    zwischen 0 und 1023 an den "Serial-Monitor" gesendet.   */  if (sensorWert < 200 )           // wenn der Sensorwert kleiner 200 beträgt = Dämmerung  {    digitalWrite(LED, HIGH);       // soll die LEDweis leuchten - Dämmerungs-Schalter  }  else                             // andernfalls ..  {    digitalWrite(LED, LOW);        // soll sie nicht leuchten  }  delay (1000);                    // jede Sekunde eine Mess-Wert-Ausgabe}                                  // mit dieser letzten Klammer wird der Loop-Teil geschlossen/* Wenn nun der Sensor-Wert bei normaler Helligkeit  z.B. nur den Wert 250 hat (Der Wert ist abhängig von dem verwendeten Widerstand 1k..10k,  von der Helligkeit und von dem LDR-Widerstand),  dann nimmt man anstelle des Wertes 200 einen kleineren Wert,  bei dem die LED zu leuchten beginnen soll.  z.B. nimmt man dann den Wert 90.  Den aktuellen Sensorwert kann man sich nun mit Hilfe des „Serial-Monitor“ anzeigen lassen.  Dazu klickt man oben rechts auf den Button „Lupe“ = der „Serial-Monitor“ */

// Titel: 3.7  Blink-Geschwindigkeit mit Potentiometer// Beschreibung: Regeln der Blink-Geschwindigkeit mit Potentiometer// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_7_Regeln_der_Blinkgeschwindigkeit_mit_Potentiometer_1a.ino// Shield: keines// Controller: Arduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_7_Regeln_der_Blinkgeschwindigkeit_mit_Potentiometer_1c// 5V  1-Pot10k-2  pin-A0   2-Pot10k-3  GND  // pin-13 LEDorange OnBoardint eingang= A0;                // „eingang“ steht jetzt für den rohWert an pin-A0int LED = 13;                   // das Wort „LED“ steht jetzt für den Wert 13int sensorwert = 0;             // Variable für den Sensorwert - mit 0 als Startwertint Faktor = 10;                // Verlängerungs-Faktor x10void setup()                    // hier beginnt das Setup.{  pinMode (LED, OUTPUT);        // pin-13 mit der OnBoard-LEDorange ist jetzt ein Ausgang}void loop()                     // das Hauptprogramm beginnt.{                               // mit dieser Klammer wird der Loop-Teil geöffnet  //sensorwert = analogRead(eingang);  sensorwert = analogRead(eingang) * Faktor;  /* die Spannung am Drehregler wird auslesen und als Zahl zwischen 0 und 1023    unter der Variable „sensorwert“ gespeichert.   */  digitalWrite (LED, HIGH);     // die LED wird eingeschaltet  delay (sensorwert);  /* Die LED bleibt für so viele Millisekunden eingeschaltet,   wie der Wert von „sensorwert“ es gespeichert hat.    */  digitalWrite (LED, LOW);     // die LED wird ausgeschaltet.  delay (sensorwert);  /* Die LED bleibt für so viele Millisekunden ausgeschaltet,   wie der Wert von „sensorwert“ es gespeichert hat.    */}                              //  mit dieser Klammer wird der Loop-Teil geschlossen/*  der Loop-Teil wird nun erneut gestartet. Wenn sich die Spannung des Drehreglers ändert, dann ändert sich auch die Zeit zwischenden Ein- und Aus-Phasen der LED. Das Blinken wird dadurch schneller und langsamer. Das längste delay beträgt in diesem Sketch 1023ms (Millisekunden). Beispiel Faktor 10 Man ändert die Zeile „sensorwert =analogRead(eingang);     in „sensorwert = analogRead(eingang) * Faktor;Damit wird der abgespeicherte Sensorwert um den Faktor 10 vergrößert. */

// Titel: 3.8 Der Bewegungsmelder - Wärme-Melder mit Buzzer// Beschreibung: Bewegungsmelder PIR-Modul HC-SR501// Autor: Fritz Prenninger// Datum: 2014-09-25// Sketch: _3_8_Der_Bewegungsmelder_mit_PIR_Modul_HC_SR501_1a.ino// Shield: keines// Controller: Arduino UNO Rev3// Version: Arduino 1.0.5-r2// Tools: COM3// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_8_Der_Bewegungsmelder_mit_PIR_Modul_HC_SR501_1a// 5V  Vcc-PIR-out  pin-A0   out-PIR-GND  GND  // pin-13 LEDorange OnBoardint piezo=5;                    // das Wort „piezo“ steht jetzt für den Wert 5int bewegung=3;                 // das Wort „bewegung“ steht jetzt für den Wert 3int bewegungsstatus=0;/* Das Wort „bewegungsstatus“ steht jetzt zunächst für den Wert 0.  Später wird unter dieser Variable gespeichert, ob eine Bewegung erkannt wird oder nicht */void setup()                    // hier beginnt das Setup{  pinMode(piezo, OUTPUT);       // der pin-5 mit dem Piezo ist jetzt ein Ausgang  pinMode(bewegung, INPUT);     // der pin-3 des Bewegungsmelder ist jetzt ein Eingang}void loop()                     // der Loop-Teil beginnt{                               // mit dieser Klammer wird der Loop-Teil geöffnet  bewegungsstatus=digitalRead(bewegung);  /* Hier wird der pin-3 ausgelesen.    Das Ergebnis wird unter der Variablen „bewegungsstatus“    mit dem Wert „HIGH“ für 5 Volt oder „LOW“ für 0Volt gespeichert.   */  if (bewegungsstatus == HIGH)  // Verarbeitung: Wenn eine Bewegung detektiert wird  {                             // Programmabschnitt des if-Befehls öffnen.    digitalWrite(piezo, HIGH);  // dann soll der Piezo piepsen.    delay(3000);                // min. 3 Sekunden je nach Potieinst. (PIR-Poti 3..200sec.)    digitalWrite(piezo, LOW);   // danach soll Piezo-Lautsprecher leise sein.  }                             // Programmabschnitt des if-Befehls schließen.  else                          // ansonsten...  {                             // Programmabschnitt des else-Befehls öffnen.    digitalWrite(piezo, LOW);   // soll der Piezo-Lautsprecher aus sein.  }                             // Programmabschnitt des else-Befehls schließen.}                               // mit dieser letzten Klammer wird der Loop-Teil geschlossen.

// Titel: 3.9  Temperatur messen mit OGW// Beschreibung: Temperatur messen mit TMP36 und Alarm// Autor: Fritz Prenninger// Datum: 2014-09-26// Sketch: _3_9_Temperaturen_messen_mit_TMP36_und_Buzzer_1b.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_9_Temperaturen_messen_mit_TMP36_und_Buzzer_1b// 5V  1-TMP36-2  pin-A0   2-TMP36-3  GND  // pin-5   +Buzzer-  GNDint TMP36 = A0;        // der mittlere-pin an pin-A0, wir nennen A0 ab jetzt "TMP36"//int TMP36 = 0;       // andere Schreibweise ohne A - verständlicher aber mit A0int temperatur = 0;    // unter der Variablen "temperatur" wird der Temp.Wert gespeichertint messung[5];        // Mittelwert aus 5 Messungen bilden/* Damit man gute Werte erhält, liest man zunächst 5 Werte aus und bildet den Mittelwert.  Die eckige Klammer „[5]“ erzeugt hier gleich 5 Variablen mit den Namen  „temp[1]“, „temp[2]“, „temp[3]“, „temp[4]“, „temp[5]“,  Mit der Schreibweise [5] spart man also Platz */int time= 500;   /* der Wert für „time“  (min.20ms) gibt im Code die zeitlichen Abstände  zwischen den einzelnen Messungen vor */int piezo=5;          // das Wort "piezo" steht  jetzt für pin-5  Buzzervoid setup() {  /* im Setup beginnen wir die serielle Kommunikation, damit wir uns die Temperatur später    auch anzeigen lassen können. Über die serielle Kommunikation sendet das Board    die Messwerte an den “Serial-Monitor”. In der Arduino-IDE kann man unter „Tools“ den    „Serial-Monitor“ starten um die Messwerte zu sehen.   */  Serial.begin(9600);  pinMode (piezo, OUTPUT);  /* der Piezo-Lautsprecher an pin-5 soll ein Ausgang sein,    weil der ja vom Mikrokontroller-Board eine Spannung benötigt um zu piepsen    */}/* ab hier wird 5x die Temperatur ausgelesen.  Dazwischen ist je eine kleine Pause mit der Dauer „time“ in Millisekunden.  Aber was passiert hier genau? Sehen wir uns den Befehl einmal genauer an. temp[1] = map(analogRead(TMP36), 0, 410, -50, 150); Der Reihe nach: temp[1] - ist der Name der ersten Variablen. „map ( a, b, c, d, e)“ - Dies ist der sogenannte „Map-Befehl“.  Hiermit kann man einen eingelesenen Wert (a) bei dem die Werte zwischen (b) und (c) liegen,  in einen anderen Zahlenbereich umwandeln, und zwar in den Bereich zwischen (d) und (e). */void loop()                       // der Hauptteil{                                               messung[1] = map(analogRead(TMP36), 0, 410, -50, 150);  delay(time);  messung[2] = map(analogRead(TMP36), 0, 410, -50, 150);  delay(time);  messung[3] = map(analogRead(TMP36), 0, 410, -50, 150);  delay(time);  messung[4] = map(analogRead(TMP36), 0, 410, -50, 150);  delay(time);  messung[5] = map(analogRead(TMP36), 0, 410, -50, 150);  /* In unserem Befehl passiert folgendes:   Der Wert des Sensors wird unmittelbar im „Map-Befehl“ ausgelesen mit „analogRead(TMP36)“   Die roh-Messwerte sollten zwischen 0 und 410 liegen.    Das entspricht am analogen Port den Werten zwischen 0V und 2V.    Die Spannung gibt der Sensor bei Temperaturen zwischen -50°C und +150°C aus.    Diese Werte am analogen Port werden nun durch den „Map-Befehl“    direkt in die °Celsius Werte zwischen -50 und 150 umgewandelt.   */  temperatur=(messung[1]+messung[2]+messung[3]+messung[4]+messung[5])/5;        /* ACHTUNG: alles in eine Zeile!     hier werden alle 5 ermittelten Temperaturwerte zusammengerechnet und durch 5 geteilt.   Der durchschnittliche Wert wird unter der Variablen „temperatur“ gespeichert   */  Serial.print(temperatur);  Serial.println(" Grad Celsius");  /* nun wird der Wert „temperatur“ über die serielle Kommunikation an den PC gesendet.    den "Serial-Monitor" in der Arduino-IDE öffnen um die Temperatur am Sensor abzulesen   */  if (temperatur>=22)              // es wird eine if-Bedingung erstellt:     // Wenn der Wert für die Temperatur über oder gleich 22 ist, dann ..   {    digitalWrite(piezo,HIGH);      // fange an zu piepsen.   }  else                             // und wenn das nicht so ist ..   {    digitalWrite(piezo,LOW);       // dann piepse nicht  }  }








// Titel: 3.9c  Temperatur messen mit MittelWertBildung// Beschreibung: Mittlere Temperatur messen mit TMP36 (Mehrfache Messungen)// Autor: Fritz Prenninger// Datum: 2014-09-26// Sketch: _3_9c_Temperaturen_messen_mit_TMP36_Mittelwert_1b.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_9c_Temperaturen_messen_mit_TMP36_Mittelwert_1b// 5V  1-TMP36-2  pin-A0   2-TMP36-3  GND  // pin-5   +Buzzer-  GNDfloat tempC = 0;int tempPin = A0;                 // Eingang Analog-Port A0 = pin-A0int messung[5];                    // 5 Messungen für Verbesserung des Messwertesint valTemp;                       // int nicht float = Gleitkomma-Zahlint i;int piezo=5;          // das Wort "piezo" steht jetzt für pin-5 Buzzer-Anschlussvoid setup()                       //  hier beginnt das Setup.{   Serial.begin(9600);              // Serielle Schnittstelle initialisieren  pinMode (piezo, OUTPUT);         // der Buzzer an pin-5 ist ein Ausgang}void loop(){  for(i=0;i<=4;i++)                // Schleife über die 5 Messungen  {    valTemp = analogRead(tempPin); // Analogport einlesen    Serial.print(" Wert");            // Trenn-Zeichen    Serial.print(valTemp);         // Ausgaber der zu mittelnden Roh-Werte    messung[i] = (5.0 * valTemp * 100.0)/1023.0;   // roh-Wert konvertieren    tempC=tempC+messung[i];    delay(1000);                   // 1 Sekunde Wartezeit  }  tempC = tempC/5;                 // Mittelwert der Messungen  tempC=tempC/3.5;                 // Zeile nur bei TMP36  -  nicht bei LM53   // Wert an serielle Schnittstelle senden  Serial.print("   Mittel-Wert: ");      // Ausgabe Text "mittel"  Serial.print(tempC);  Serial.println(" Grad C");        // Ausgabe Text "Grad Celsius"  delay(5000) ;                    // 5 Sekunden  warten  if (tempC >= 24)                 // es wird eine if-Bedingung erstellt:     // Wenn der Wert für die Temperatur über oder gleich 24 °C ist, dann...   {    digitalWrite(piezo,HIGH);      // fange an zu piepsen.   }  else                             // und wenn das nicht so ist...   {    digitalWrite(piezo,LOW);       // dann piepse nicht   }  tempC=0;}

// Titel: 3.10b Entfernung messen mit US-Modul HC-SR04 und Buzzer// Beschreibung: Abstand messen 2cm bis 5m// Autor: Fritz Prenninger// Datum: 2014-09-26// Sketch: _3_10b_Entfernung_messen_mit_US-Modul_HC_SR04_und_Buzzer_1c.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_10b_Entfernung_messen_mit_US-Modul_HC_SR04_und_Buzzer_1c// HC-SR04  1. Vcc auf +5V   2. Trig auf pin-7   3. Echo auf pin-6    4. GND auf GND  // pin-5   +Buzzer-  GND/* Anstelle von "int" steht bei 2 Variablen "long". Das hatden Vorteil, dass eine größere Zahl gespeichert werden kann,den Nachteil, die Variable benötigt mehr Platz im Speicher. */ int trigger=7;                         // das Wort trigger steht für pin-7int echo=6;                            // das Wort echo steht für pin-6long dauer=0;/* Das Wort dauer ist eine Variable, unter der die Zeit gespeichert wird, die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0. */long entfernung=0; // "entfernung" ist jetzt die Variable, unter der die Entfernung gespeichert wird.int piezo=5;                          // das Wort piezo steht jetzt für pin-5 
void setup()                          // hier beginnt das Setup{  Serial.begin (9600);     /*die serielle Kommunikation starten,   damit man sich später die Werte am "Serial-Monitor" ansehen kann  */  pinMode(trigger, OUTPUT);           // "trigger" (pin-7) ist ein Ausgang  pinMode(echo, INPUT);               // "echo" (pin-6) ist ein Eingang  pinMode(piezo, OUTPUT);/* Der Piezo-Lautsprecher an pin-5 soll ein Ausgang sein, weil der ja vom Mikrokontroller-Board ja eine Spannung benötigt um zu piepsen. */}void loop()                           // der Loop Teil = Hauptprogramm{  digitalWrite(trigger, LOW);     /* Hier nimmt man die Spannung für kurze Zeit vom Trigger pin-7,   damit man später beim Senden des Trigger-Signals ein rauschfreies Signal hat.   */  delay(5);                           // 5 Millisekunden Wartezeit  digitalWrite(trigger, HIGH);        // jetzt sendet man eine Ultraschallwelle los  delay(10);                          // dieser "Ton" erklingt für 10 Millisekunden  digitalWrite(trigger, LOW);         // dann wird der "Ton" abgeschaltet  dauer = pulseIn(echo, HIGH);   /* Mit dem Befehl "pulseIn" zählt der Mikrocontroller die Zeit in Millisekunden,   bis der Schall zum Ultraschallsensor zurückkehrt.   */  entfernung = (dauer/2) / 29.1;  /* Nun berechnet man die Entfernung in Zentimetern.   Man teilt zunächst die Zeit durch zwei   (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück).   Den Wert teilt man noch durch 29,1 und erhält dann den Wert in cm, da der Schall   in der Luft eine Geschwindigkeit von 1cm / 29,1 Mikrosekunden hat.   Beispiel: Der Sensor misst eine Zeit von 2000 Mikrosekunden.    Das sind dann 1000 Mikrosekunden pro Strecke.    Nun teilt man 1000 durch 29.1  und erhält den Wert 34,3cm   */  if (entfernung >= 500 || entfernung <= 1)    /* Wenn die gemessene Entfernung über 500cm oder unter 1cm liegt,      dann soll "Kein Messwert" am "Serial-Monitor" ausgeben werden,       weil Messwerte in diesen Bereichen falsch oder ungenau sind.     */  {    Serial.println("Kein Messwert");  }  else   // ansonsten ..  {    Serial.print(entfernung);          // Entfernung an den "Serial-Monitor"     Serial.println(" cm");  }    if (entfernung <= 50)                // es wird eine weitere if-Bedingung erstellt,                   {               // wenn der Wert für die Entfernung unter oder gleich 50cm ist, dann ..  digitalWrite(piezo,HIGH);            // fange an zu piepsen.   delay(200);  digitalWrite(piezo,LOW);   }  else                                 // und wenn das nicht so ist ..   {  digitalWrite(piezo,LOW);             // dann soll Buzzer leise sein  }  delay(500);                          // in ca. jeder neuen Sekunde einen neuen Messwert.}

// Titel: 3.10.1 Kfz-Rückfahrwarner HC-SR04+Buzzer+LED// Beschreibung: Abstand messen 2cm bis 5m// Autor: Fritz Prenninger// Datum: 2014-09-26// Sketch: _3_10_1_Kfz_Rückfahrwarner_HC_SR04_Buzzer_LED_1c.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_10_1_Kfz_Rückfahrwarner_HC_SR04_Buzzer_LED_1c// HC-SR04  1. Vcc auf +5V   2. Trig auf pin-7   3. Echo auf pin-6    4. GND auf GND  // pin-5   +Buzzer-  GND// pin-13 OnBoard LED/* Anstelle von "int" steht bei 2 Variablen "long". Das hat den Vorteil, dass eine größere Zahl gespeichert werden kann, den Nachteil, die Variable benötigt mehr Platz im Speicher. */int trigger=7;                         // das Wort trigger steht für pin-7int echo=6;                            // das Wort echo steht für pin-6long dauer=0;int LED=13;                            //OnBoard LED pin-13/* Das Wort dauer ist eine Variable, unter der die Zeit gespeichert wird,  die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0. */long entfernung=0; // "entfernung" ist jetzt die Variable, unter der die Entfernung gespeichert wird.int piezo=5;                          // das Wort piezo steht jetzt für pin-5 void setup()                          // hier beginnt das Setup{  Serial.begin (9600);     /*die serielle Kommunikation starten,    damit man sich später die Werte am "Serial-Monitor" ansehen kann   */  pinMode(trigger, OUTPUT);           // "trigger" (pin-7) ist ein Ausgang  pinMode(echo, INPUT);               // "echo" (pin-6) ist ein Eingang  pinMode(piezo, OUTPUT);             // "Buzzer" (pin-5) ist ein Ausgang  pinMode(LED, OUTPUT);               // "LED" (pin-13) ist ein Ausgang  /* Der Piezo-Lautsprecher an pin-5 soll ein Ausgang sein,    weil der ja vom Mikrokontroller-Board ja eine Spannung benötigt um zu piepsen.    */}void loop()                           // der Loop Teil = Hauptprogramm{  digitalWrite(trigger, LOW);     /* Hier nimmt man die Spannung für kurze Zeit vom Trigger pin-7,    damit man später beim Senden des Trigger-Signals ein rauschfreies Signal hat.   */  delay(5);                           // 5 Millisekunden Wartezeit  digitalWrite(trigger, HIGH);        // jetzt sendet man eine Ultraschallwelle los  delay(10);                          // dieser "Ton" erklingt für 10 Millisekunden  digitalWrite(trigger, LOW);         // dann wird der "Ton" abgeschaltet  dauer = pulseIn(echo, HIGH);   /* Mit dem Befehl "pulseIn" zählt der Mikrocontroller die Zeit in Millisekunden,    bis der Schall zum Ultraschallsensor zurückkehrt.   */  entfernung = (dauer/2) / 29.1;  /* Nun berechnet man die Entfernung in Zentimetern.    Man teilt zunächst die Zeit durch zwei    (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück).    Den Wert teilt man noch durch 29,1 und erhält dann den Wert in cm, da der Schall    in der Luft eine Geschwindigkeit von 1cm / 29,1 Mikrosekunden hat.   Beispiel: Der Sensor misst eine Zeit von 2000 Mikrosekunden.    Das sind dann 1000 Mikrosekunden pro Strecke.    Nun teilt man 1000 durch 29.1  und erhält den Wert 34,3cm   */  if (entfernung >= 500 || entfernung <= 1)    /* Wenn die gemessene Entfernung über 500cm oder unter 1cm liegt,      dann soll "Kein Messwert" am "Serial-Monitor" ausgeben werden,       weil Messwerte in diesen Bereichen falsch oder ungenau sind.     */  {    Serial.println("Kein Messwert");  }  else   // ansonsten ..  {    Serial.print(entfernung);          // Entfernung an den "Serial-Monitor"     Serial.println(" cm");  }  if (entfernung <= 80)                   // es wird eine weitere if-Bedingung erstellt,                   {               // wenn der Wert für die Entfernung unter oder gleich 80cm ist, dann ..    digitalWrite(piezo,HIGH);              // fangt an zu piepsen.     digitalWrite(LED,HIGH);                // fangt an zu blinken.     delay(entfernung*4);    digitalWrite(piezo,LOW);     digitalWrite(LED,LOW);     delay(entfernung*4);  }}

InfraroFernbedienung

BUCH: Mikrocontroller verstehen und anwenden, C. Valens

Seite 268 IR-Fernsteuerung PPM-Codierung Pulse Position Modulation 36kHz TSOP1736 besser TSOP34836
Seite 372 IR-Empfänger TSOP34836
Seite 374 IR-Sender mit Infrarot LED (IR-LED 5mm) HDSL-4230 BPW40 BPW34

Seite 375 Akustikschalter  ECM   TSOP34836   HDSL-4230

BUCH: ... Arduino entdecken, E. Bartmann
Seite 177 IR-Empfänger TSOP1736 (GND V+ Out) am Arduino

// Titel: 3.11B InfraroFernbedienung mit IR-Diode VS1838B// Beschreibung: Zahlenausgabe auf "Serial-Monitor"// Autor: Fritz Prenninger// Datum: 2014-09-26// Sketch: _3_11B_InfraroFernbedienung_IR_Diode_VS1838B_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_11B_InfraroFernbedienung_IR_Diode_VS1838B_1a// VS1838B  1. Out auf pin-11   2. GND auf GND   3. Vcc auf +5V /* Informationen über das ursprüngliche Programm „IrrecvDemo“. IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv An IR detector/demodulator must be connected to the input RECV_PIN. Version 0.1 July, 2009 Copyright 2009 Ken Shirriff http://arcfn.com */#include <IRremote.h>/* Das Programm greift an dieser Stelle auf eine „Library“ zurück.  Das erleichtert einem viel Arbeit.  Denn das Infrarotlicht wird mit einem Code verschlüsselt gesendet. Um diesen Code selber  auszulesen und in passende Werte umzuwandeln, wären sehr viele Zeilen Code erforderlich. */int RECV_PIN = 11; // der Kontakt der am Infrarotsensor die Daten ausgibt, wird mit pin-11 verbunden.IRrecv irrecv(RECV_PIN);// an dieser Stelle wird ein Objekt definiert, dass den Infrarotsensor an pin-11 ausliest.decode_results results;/* dieser Befehl sorgt dafür, dass die Daten, die per Infrarot eingelesen werden  unter „results“ abgespeichert werden. */void setup()/* Im Setup wird die Serielle Verbindung gestartet, damit man sich die Empfangenen Daten  der Fernbedienung per „Serial-Monitor“ ansehen kann. */{  Serial.begin(9600);  irrecv.enableIRIn();              // dieser Befehl initialisiert den Infrarotempfänger.}void loop() {  // der loop-Teil fällt durch den Rückgriff auf die „library“ sehr kurz aus.  if (irrecv.decode(&results)) {          // wenn Daten empfangen wurden,     Serial.println(results.value, DEC);   // als Dezimalzahl an den "Serial-Monitor"     irrecv.resume();         // der nächste Wert soll vom IR-Empfänger eingelesen werden.  }}

// Titel: 3.11D InfraroFernbedienung - alle Tasten// Beschreibung: Zahlenausgabe auf "Serial-Monitor"// Autor: Fritz Prenninger// Datum: 2014-09-26// Sketch: _3_11D_InfraroFernbedienung_alle_Tasten_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_11D_InfraroFernbedienung_alle_Tasten_1a// VS1838B  1. Out auf pin-11   2. GND auf GND   3. Vcc auf +5V #include <IRremote.h>int RECV_PIN = 11;            IRrecv irrecv(RECV_PIN);decode_results results;#define CH1 0xFFA25D #define CH 0xFF629D#define CH2 0xFFE21D//...#define BUTON_EQ 0xFF906F#define BUTON_plus 0xFFA857#define BUTON_minus 0xFFE01F#define BUTON0 0xFF6897   geht nicht weiß nicht warum
#define BUTON1 0xFF30CF#define BUTON2 0xFF18E7#define BUTON3 0xFF7A85#define BUTON4 0xFF10EF#define BUTON5 0xFF38CF   geht nicht weiß nicht warum
#define BUTON6 0xFF5AA5#define BUTON7 0xFF42BD#define BUTON8 0xFF4AB5#define BUTON9 0xFF52AD
void setup(){  Serial.begin(9600);  irrecv.enableIRIn(); }void loop() {  if (irrecv.decode(&results))   {    if (results.value == CH1)     {      Serial.println("CH-");     }    if (results.value == CH)     {      Serial.println("CH");     }    if (results.value == CH2)     {      Serial.println("CH+");     }        //...        if (results.value == BUTON_EQ)     {      Serial.println("BUTON_EQ");     }    if (results.value == BUTON_plus)     {      Serial.println("BUTON_plus");     }    if (results.value == BUTON_minus)     {      Serial.println("BUTON_minus");     }    if (results.value == BUTON1)     {      Serial.println("BUTON1");     }    if (results.value == BUTON2)     {      Serial.println("BUTON2");     }    if (results.value == BUTON3)     {      Serial.println("BUTON3");     }    if (results.value == BUTON4)     {      Serial.println("BUTON4");     }    if (results.value == BUTON5)     {      Serial.println("BUTON5");     }    if (results.value == BUTON6)     {      Serial.println("BUTON6");     }    if (results.value == BUTON7)     {      Serial.println("BUTON7");     }    if (results.value == BUTON8)     {      Serial.println("BUTON8");     }    if (results.value == BUTON9)     {      Serial.println("BUTON9");     }    irrecv.resume();  }}

// Titel: 3.12  microServo9g SG90 ansteuern// Beschreibung: Positionen zwischen 0 und 180 Grad anfahren// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_12_microServo9g_Tower_Pro_SG90_ansteuern_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_12_microServo9g_Tower_Pro_SG90_ansteuern_1a// microServo 9g SG90  1. braun auf GND   2. rot auf +5V   3. gelb auf pin-8#include <Servo.h>    /* die Servo-Biliothek wird aufgerufen. Sie wird benötigt, damit die Ansteuerung des Servos vereinfacht wird.*/Servo servoblau;   // erstellt für das Programm ein Servo mit dem Namen "servoblau"void setup()   {  servoblau.attach(8);  /* das Setup enthält die Information, dass das Servo an der Steuerleitung (gelb)  mit pin-8 verbunden wird. Hier ist natürlich auch ein anderer Pin möglich.   */}void loop() /* im "loop" wird über den write-Befehl "servoblau.write(Grad)" das Servo angesteuert. Zwischen den einzelnen Positionen gibt es eine Pause, damit das Servo genug Zeit hat, die gewünschten Positionen zu erreichen. */{  servoblau.write(0);        // Position 1 ansteuern  - Winkel 0°  delay(1000);               // für 180 Grad braucht das Servo 1 Sekunde  servoblau.write(180);      // Position 1 ansteuern  - Winkel 180°  delay(1000);               // das Programm stoppt für 1 Sekunden  servoblau.write(0);        // Position 1 ansteuern  - Winkel 0°  delay(6000);               // das Programm stoppt für 6 Sekunden  servoblau.write(45);       // Position 2 ansteuern - Winkel 45°  delay(2000);               // das Programm stoppt für 2 Sekunden  servoblau.write(90);       // Position 3 ansteuern - Winkel 90°  delay(2000);               // das Programm stoppt für 2 Sekunden  servoblau.write(135);      // Position 4 ansteuern - Winkel 135°  delay(2000);               // das Programm stoppt für 2 Sekunden  servoblau.write(180);      // ACHTUNG: je nach Servo konnen 180 Grad auch 190 Grad sein  delay(3000);               // Werte dem Servo anpassen  servoblau.write(135);      // Position 6 ansteuern - Winkel 135°  delay(1000);               // das Programm stoppt für 1 Sekunden  servoblau.write(90);       // Position 7 ansteuern - Winkel 90°  delay(1000);               // das Programm stoppt für 1 Sekunden  servoblau.write(45);       // Position 7 ansteuern - Winkel 45°  delay(1000);               // das Programm stoppt für 1 Sekunden}

// Titel: 3.19b Arduino Feuchtigkeitssensor mit Buzzer// Beschreibung: Widerstands-Messungen Offen=0  10k=625  Kurzschluß=872// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_19b_Arduino_Feuchtigkeitssensor_mit_Buzzer_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_19b_Arduino_Feuchtigkeitssensor_mit_Buzzer_1a// oder Seeed Studio  SEN92355P// - GND auf GND (schwarz)   + Vcc auf +5V (rot)   n.c  (weiß)  S Signal auf pin-A0 (gelb)//  pin-6  +Buzzer-  GND int sensorPin = A0; // wählen Sie den Eingangs-Pin für den Erdfeuchte-Sensorint messwert = 0;   // unter der Variablen "messwert" wird der Wert  gespeichertint Buzzer = 6;     // mit dem Namen "Buzzer" wird jetzt der pin-6 bezeichnetvoid setup()                // hier beginnt das Setup.{  Serial.begin(9600);    /* Die Kommunikation mit dem seriellen Port wird gestartet.    Das benötigt man, um sich den ausgelesenen Wert im "Serial-Monitor" anzeigen zu lassen.   */  pinMode (Buzzer, OUTPUT); // im Setup wird der pin-6 als Ausgang festgelegt.}void loop()                  // hier beginnt der Hauptteil{                            // mit dieser Klammer wird der Loop-Teil geöffnet.  messwert=analogRead(sensorPin);     // Die Spannung an dem Sensor wird gelesen und unter der Variable „messwert“ gespeichert.  Serial.print("Feuchte-Messwert: ");     // Ausgabe am Serial-Monitor: Das Wort „Feuchtigkeits-Messwert:   Serial.println(messwert);  // Messwert-Ausgabe am "Serial-Monitor"  delay(4000);                // 4sec Pause, damit nicht zu viele Zahlenwerte entstehen   if (messwert <200 )            // wenn der Sensorwert kleiner als "200" ist  {    digitalWrite(Buzzer, HIGH);  //  der Buzzer piepst 1 Sekunde    delay(1000);                     digitalWrite(Buzzer, LOW);   }  else                           // ansonsten  {    digitalWrite(Buzzer, LOW);   //  der Piezo-Speaker ist leise  } }/*  0 Ohm = 872 100R  = 868 200R  = 864 330R  = 860 1k    = 839 10k   = 625 Hautwiderstand = 10 .. 40 Offen   = 0 */

// Titel: 3.20a Arduino FlüssigkeitsSensor Fa. Funduino Tropfensensor// Beschreibung: Regensensor// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_19b_Arduino_Feuchtigkeitssensor_mit_Buzzer_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_20a_Arduino_FlüssigkeitsSensor_1a// oder Seeed Studio  Grove - Water Sensor  SEN11304P// - GND auf GND (schwarz)   + Vcc auf +5V (rot)   n.c  (weiß)  S Signal auf pin-A0 (gelb)//  pin-6  +Buzzer-  GND int sensorPin = A0; // wählen Sie den Eingangs-Pin für den Erdfeuchte-Sensorint messwert=0;  // unter der Variablen "messwert" wird später der Messwert des Sensors gespeichertvoid setup()                       // hier beginnt das Setup{  Serial.begin(9600);     /* Die Kommunikation mit dem seriellen Port wird gestartet.    Das benötigt man, um sich den ausgelesenen Wert im "serial monitor" anzeigen zu lassen   */}void loop()                         // hier beginnt der Hauptteil{                                   //  mit dieser Klammer wird der Loop-Teil geöffnet  messwert=analogRead(sensorPin);     // Die Spannung am pin-A0 wird gelesen und unter der Variable „messwert“ gespeichert  Serial.print("Wasser-Messwert: "); // am den "Serial-Monitor"  Serial.println(messwert);         // Messwert-Ausgabe am Serial-Monitor  delay(2000);  // 2sec.  Pause, damit nicht zu viele Zahlenwerte entstehen}/* Seeed Studio SEN11304P Trocken        Wert 1023 Hautwiderstand  Wert 700 1 Tropfen       Wert 225 2 Tropfen       Wert 200 3 Tropfen       Wert 180 Voll im Wasser  Wert 165 */

// Titel: 3.20b Arduino FlüssigkeitsSensor mit Buzzer// Beschreibung: Regensensor// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_20b_Arduino_Fluessigkeitssensor_mit_Buzzer_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_20b_Arduino_FluessigkeitsSensor_mit_Buzzer_1a// oder Seeed Studio  Grove - Water Sensor  SEN11304P// - GND auf GND (schwarz)   + Vcc auf +5V (rot)   n.c  (weiß)  S Signal auf pin-A0 (gelb)//  pin-6  +Buzzer-  GND int sensorPin=A0; // wählen Sie den Eingangs-Pin für den Erdfeuchte-Sensorint messwert=0;  int Buzzer=6; /* Mit dem Namen "Buzzer" wird jetzt der pin-6 bezeichnet, an dem ein Piezo-Speaker angeschlossen wird. unter der Variablen "messwert" wird später der Messwert des Sensors gespeichert.*/void setup()                       // hier beginnt das Setup{  Serial.begin(9600);     /* Die Kommunikation mit dem seriellen Port wird gestartet.    Das benötigt man, um sich den ausgelesenen Wert im "serial monitor" anzeigen zu lassen   */  pinMode (Buzzer,OUTPUT); // im Setup wird der pin-6 als Ausgang festgelegt. }void loop()                         // hier beginnt der Hauptteil{                                   //  mit dieser Klammer wird der Loop-Teil geöffnet  messwert=analogRead(sensorPin);     // Die Spannung am pin-A0 wird gelesen und unter der Variable „messwert“ gespeichert  Serial.print("Wasser-Messwert: "); // am den "Serial-Monitor"  Serial.println(messwert);          // Messwert-Ausgabe am Serial-Monitor  delay(4500);  // 4,5sec.  Pause, damit nicht zu viele Zahlenwerte entstehen    if (messwert <400 )    // Abfrage: Wenn der Sensorwert kleiner /größer als "400" ist, dann ..   {    digitalWrite(Buzzer, HIGH);      // soll der Buzzer 0,5 Sek. piepsen.     delay(500);    digitalWrite(Buzzer, LOW);   }  else                               // ...ansonsten...   {    digitalWrite(Buzzer, LOW);       // soll der Piezo-Speaker leise sein  }}/* Seeed Studio Grove - Water Sensor  SEN11304P Trocken        Wert 1023 Hautwiderstand  Wert 700 1 Tropfen       Wert 225 2 Tropfen       Wert 200 3 Tropfen       Wert 180 Voll im Wasser  Wert 165 */

// Titel: 3.13a Das LCD Display 2x16 1602A_1a.ino// Beschreibung: 16x2 LCD display Fa. QAPASS 1602A// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_13a_Das_LCD_Display_2x16_1602A_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_13a_Das_LCD_Display_2x16_1602A_1a// 16x2 LCD display with Arduino   Fa. QAPASS 1602A/* GND   5V Pot  12  GND 11  nc  nc  nc  nc  p6  p5  p4  p3  5V  GND Vss  Vdd  Vo  RS   RW  E  D0  D1  D2  D3  D4  D5  D6  D7   A    K pin1   2   3   4    5  6   7   8   9  10  11  12  13  14  15   16  */// Spannungsteiler  5V 10k LCDpin3 47k GND  LCD-Kontrast Einstellung#include <LiquidCrystal.h>     // LCD-Bibliothek (library "LiquidCrystal.h") ladenLiquidCrystal lcd(12, 11, 6, 5, 4, 3);   /* In dieser Zeile wird festgelegt, welche Pins des MikrocontrollerBoards für das LCD verwendet werden (Am besten erstmal nicht verändern). */void setup() {    // Im Setup wird angegeben, wie viele Zeichen und Zeilen werwendet werden.   lcd.begin(16, 2);  //  Hier: 16 Zeichen in 2 Zeilen}void loop() {  /* Startposition der Darstellung auf dem LCD festlegen.    lcd.setCursor(0,0) bedeutet: Erstes Zeichen in der ertsen Zeile.    Dort soll der Text „sites.prenninger“ erscheinen.   */  lcd.setCursor(0, 0);     // der Befehl lcd.setCursor ist dem board durch das Aufrufen der Bibliothek bekannt.   lcd.print("sites.prenninger");  lcd.setCursor(0, 1);                  // lcd.setCursor(0,1) bedeutet: Erstes Zeichen in der zweiten Zeile.   lcd.print(" schaltungen.at");    // Dort sollte dann der Text „schaltungen.at“ auftauchen. }

// Titel: 3.13b Das LCD Display 2x16 1602A blinkend_1a.ino// Beschreibung: 16x2 LCD display Fa. QAPASS 1602A// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_13b_Das_LCD_Display_2x16_1602A_blinkend_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_13b_Das_LCD_Display_2x16_1602A_blinkend_1a// 16x2 LCD display with Arduino   Fa. QAPASS 1602A/* GND   5V Pot  12  GND 11  nc  nc  nc  nc  p6  p5  p4  p3  5V  GND Vss  Vdd  Vo  RS   RW  E  D0  D1  D2  D3  D4  D5  D6  D7   A    K pin1   2   3   4    5  6   7   8   9  10  11  12  13  14  15   16  */// Spannungsteiler  5V 10k LCDpin3 47k GND  LCD-Kontrast Einstellung#include <LiquidCrystal.h>     // LCD-Bibliothek (library "LiquidCrystal.h") ladenLiquidCrystal lcd(12, 11, 6, 5, 4, 3);   /* In dieser Zeile wird festgelegt, welche Pins des MikrocontrollerBoards für das LCD verwendet werden (Am besten erstmal nicht verändern). */void setup() {    // Im Setup wird angegeben, wie viele Zeichen und Zeilen werwendet werden.   lcd.begin(16, 2);  //  Hier: 16 Zeichen in 2 Zeilen}void loop() {  /* Startposition der Darstellung auf dem LCD festlegen.    lcd.setCursor(0,0) bedeutet: Erstes Zeichen in der ertsen Zeile.    Dort soll der Text „Prenninger“ erscheinen.   */  lcd.setCursor(0, 0);     // der Befehl lcd.setCursor ist dem board durch das Aufrufen der Bibliothek bekannt.   lcd.print("Prenninger");      // mit dem Text „Prenninger“.  delay (1000);                 // 1 Sekunden warten.  lcd.clear();                  // Display löschen.  lcd.setCursor(10, 1);         // erneuter Beginn beim fünften Zeichen in der zweiten Zeile  lcd.print("Fritz");           // mit dem Text „Fritz“.  delay (500);                  // 0,5 Sekunden warten.  lcd.clear();                  // Display löschen.}

Arduino Kochbuch Seite 366

// Titel: 3.13b Das LCD Display 2x16 1602A Zeitnehmung_1a.ino// Beschreibung: zählt die Sekunden seit dem Start// Autor: Fritz Prenninger// Datum: 2014-09-27// Sketch: _3_13e_Das_LCD_Display_2x16_1602A_Zeitnehmung_1a.ino// Shield: keines// Controller: Arduino UNO SMD// Version: Arduino 1.0.5-r2// Tools: COM4// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567// _3_13e_Das_LCD_Display_2x16_1602A_Zeitnehmung_1a// 16x2 LCD display with Arduino   Fa. QAPASS 1602A/* GND   5V Pot  12  GND 11  nc  nc  nc  nc  p6  p5  p4  p3  5V  GND Vss  Vdd  Vo  RS   RW  E  D0  D1  D2  D3  D4  D5  D6  D7   A    K pin1   2   3   4    5  6   7   8   9  10  11  12  13  14  15   16  */// Spannungsteiler  5V 10k LCDpin3 47k GND  LCD-Kontrast Einstellung/*LiquidCrystal Library - Hallo, Welt Demonstriert die Verwendung eines 16 x 2 LC-Displays. http : //www.arduino.cc/en/Tutorial/LiquidCrystal */ #include <LiquidCrystal.h> // Bibliothek einbinden//Konstanten für die Zeilen und Spalten des LCDsconst int numRows = 2;   // 2 Zeiligconst int numCols = 16;  // 16 Zeichen// Bibliothek mit den Interface-Pins initialisierenLiquidCrystal lcd(12, 11, 6, 5, 4, 3);void setup(){  lcd.begin(numCols, numRows);  lcd. print ("Hallo, Welt!"); //Meldung im LCD ausgeben.}  void loop()  {    // Cursor an Spalte 0, Zeile 1 positionieren    // (Hinweis: Zeile 1 ist die zweite Zeile, da die Zählung bei 0 beginnt):    lcd.setCursor(0, 1);  // Seit Reset verstrichene Sekunden ausgeben.  lcd.print(millis()/1000);}

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







a