SKETCH

http://sites.prenninger.com/arduino-uno-r3/sketch

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-11-05

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************



Sollte Sie bei meinen Einsteiger-Sketches Fehler entdecken, würde ich Sie bitten mir eine e-Mail zu senden damit icht diese - meist Tipp-Fehler - korrigieren kann.
Dies Sketche sind für Anfänger gedacht und da diese noch nicht das nötige Fachwissen haben sollten in den Beispielen natürlich keine Fehler sein.
MfG
fritz prenninger


Die immer vorkommenden ARDUINO Begriffe (Begrifflichkeiten ?) habe ich in einer EXCEL-Tabelle zusammengefaßt.

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


100 Ohm  braun  schwarz schwarz   schwarz   rot    ( 1 0 0   -   2% )
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_Funduino UNO 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 LEDorange

void setup()              // hier beginnt das Setup
{                         // hier beginnt ein Programmabschnitt
  pinMode(13, OUTPUT);    // pin-13 soll ein Ausgang sein
}                         // hier ist der Programmabschnitt beendet


void 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 GND void 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 beendet void 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 GND int 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 GND

int 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 GND


int taster=6;                    // das Wort „taster“  steht jetzt für den Wert 6
int LEDrot=7;                    // das Wort „LEDrot“ steht jetzt für den Wert 7
int 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 GND


const int taster=6;               // das Wort „taster“  steht jetzt für den Wert 6
const int LEDrot=7;               // das Wort „LEDrot“ steht jetzt für den Wert 7
int 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 GND

int eingang= A0;                  // „eingang“ steht jetzt für Analog-Port 0
int LED = 10;                     // das Wort „LED“ steht jetzt für den pin-10
int sensorWert = 0;               // variable für den Sensor-Wert - 0 als Start-Wert


void 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 OnBoard


int eingang= A0;                // „eingang“ steht jetzt für den rohWert an pin-A0

int LED = 13;                   // das Wort „LED“ steht jetzt für den Wert 13
int sensorwert = 0;             // Variable für den Sensorwert - mit 0 als Startwert
int Faktor = 10;                // Verlängerungs-Faktor x10


void 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 zwischen
den 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 OnBoard

int piezo=5;                    // das Wort „piezo“ steht jetzt für den Wert 5
int bewegung=3;                 // das Wort „bewegung“ steht jetzt für den Wert 3
int 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-  GND

int 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 A0
int temperatur = 0;    // unter der Variablen "temperatur" wird der Temp.Wert gespeichert

int 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  Buzzer



void 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-  GND float tempC = 0; int tempPin = A0; // Eingang Analog-Port A0 = pin-A0 int messung[5]; // 5 Messungen für Verbesserung des Messwertes int valTemp; // int nicht float = Gleitkomma-Zahl int i; int piezo=5; // das Wort "piezo" steht jetzt für pin-5 Buzzer-Anschluss void 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 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-7
int echo=6;                            // das Wort echo steht für pin-6
long 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-7
int echo=6;                            // das Wort echo steht für pin-6
long 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-Sensor
int messwert = 0;   // unter der Variablen "messwert" wird der Wert  gespeichert
int Buzzer = 6;     // mit dem Namen "Buzzer" wird jetzt der pin-6 bezeichnet

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 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-Sensor
int messwert=0;  
// 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
   */
}


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-Sensor
int 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") laden

LiquidCrystal 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") laden

LiquidCrystal 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 LCDs
const int numRows = 2;   // 2 Zeilig
const int numCols = 16;  // 16 Zeichen
// Bibliothek mit den Interface-Pins initialisieren
LiquidCrystal 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:schaltungen@schaltungen.at
ENDE








a
Untergeordnete Seiten (1): LCD-16x2
Comments