KY-011..020


http://sites.prenninger.com/arduino-uno-r3/starter-kit-lern-set/37-in-1-sensor/ky-011-020

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                        Wels, am 2017-01-06

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
Untergeordnete Seiten (9):
ArduinoSensor

ArduinoSensors

Documenta

KY-001..010

KY-011..020

KY-021..030

KY-031..040

KY-050..KY-055

Pin-Belegung

715_d_ARDUINO-x_ALLNET Arduino 37-in-1 Sensor Kit +++ Beschreibung (12 Seiten)_1a.pdf

715_d_ARDUINO-x_ALLNET Arduino 37-in-1 Sensor Kit - Experimentierkasten (7 Seiten)_1a.pdf


704_d_fritz-x_SENSOREN AM ARDUINO 2  37-in-1 (Seite 59..97)_1a.pdf

3.10   KY-011 - 2-Farben-LED
Arduino KY-011
2-farbiges LED Modul - Two-color LED 5mm
Arduino KY-029 2-farbiges LED Modul - Two-color LED mini 3mm
5mm Zwei Farben LED-Modul KY-011 für Arduino, emittiert rotes und grünes Licht.
Sie können den Betrag jeder Farbe mit PWM einstellen.
Grün Rot  Y=GND
S     = Signal
Vcc = +5,0V
-      = GND
Print 18,5x15mm


Die 5mm LED im weiß diffusen Gehäuse beinhaltet eine rote und eine grüne LED, die getrennt oder gleichzeitig angesteuert werden können, so dass sich auch eine Mischung aus Rot und Grün ergeben kann.
Der verbaute Widerstand ist mit 0 Ohm lediglich eine überflüssige Drahtbrücke.
Für den Betrieb der 2 LEDs müssen 220R  Vorwiderstände extern angelötet werden werden.

Rot:    ca. 1,9V..2,1V  15mA
Grün: ca. 2,2V..2,5V  20mA


ACHTUNG es gibt keine einheitlichen Pin-Belegungen.
Meine ist
GND (-)           Rot        Grün (S)
bei der 2-Farben LED  rot (flach)  GND (mitte)    grün (rechts)
Print überkreuzt   rot und GND
Modul-Pin         (-) GND rot grün (S)



BlackBoard Circuit Designer Schaltplan
KY-011 bis KY-020 Schaltungen_1b.bbs


KY-011 Two Color 5mm
KY-029 mini Two Color 3mm


Arduino KY-011 2-color LED module

Zwei-Farben LED Dm = 5mm  LED hat eine gemeinsame Kathode Pin bei der Abflachung

                                                      der „S“ Pin ist für Grün
                               der mittlere Pin ist für Rot
(-Pol), verbunden mit dem „-“ Pin der Platine.

Es sind keine eingebauten Vorwiderstände auf dem Modul,
geeignete externe Vorwiderstände sind z.B. 220 Ohm


KY-011 2-Farben-LED-Modul 2 Farbe led.PNG


3mm rotes und grünes LED (gemeinsames Kathodenmodul)

    
Farbe:              Grün + Rot
    
Durchmesser:   5mm
    
Gehäusefarbe:  Keine
    
Verpackung:     Diffusion
    
Spannung:                             grün 2,5V                                      rot 2,0V
    
Verwenden eines Stroms: grün 15mA (571nm) 30mcd       rot 10mA (644nm) 60mcd
    
Betrachtungswinkel:          150 Grad
    
Wellenlänge:                        571nm                                             644nm
    
Lichtstärke:                          
40..80mcd                                      20..40mcd



Arduino pin-10  grün  Widerstand 220 Ohm             zu rechten Signal-Pin des Moduls ( S )
Arduino pin-11 rot  Widerstand 330 Ohm            zu Mittel-Pin des Moduls
Arduino pin-GND                                         zu   linken Minus-Pin des Moduls  ( - )


Beispielcode für ARDUINO UNO
Sketch KY-011

// Arduino test code for KY011
int redpin = 11;     // select the pin for the red LED
int greenpin = 10;   // select the pin for the green LED
int val;

 void setup () { pinMode (redpin, OUTPUT); pinMode (greenpin, OUTPUT); }

 void loop () { for (val = 255; val> 0; val--) { analogWrite (greenpin, val); // dim red analogWrite (redpin, 255-val); // brighten green delay (15); } for (val = 0; val <255; val++) { analogWrite (greenpin, val); // brighten red analogWrite (redpin, 255-val); // dim green delay (15); // 15ms = 0,015 Sekunden }
}

http://arduinomodules.info/ky-011-two-color-led-module-3mm/

https://codebender.cc/sketch:68953#KY-011%202-color%20LED%20module.ino






Technische Daten / Kurzbeschreibung
LED-Modul welche eine rote und grüne LED beinhaltet.
Diese sind mittels gemeinsamer Kathode miteinander verbunden. Je nach Eingangsspannung, werden Vorwiderstände benötigt


Vf [typ]= 2,0-2,5V
If= 20mA

Vorwiderstände:
Rf (5V) [Grün] = 220Ω 

Rf (5V) [Rot] = 220Ω 

z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie Arduino

Pin-Belegung


LED Grün = [pin-10]
LED Rot = [pin-11]
LED Kathode GND = [pin-GND]

Codebeispiel ON/OFF

Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.

int Led_Rot = 10;
int Led_Gruen = 11;
 
void setup ()
{
  // Initialisierung Ausgangspins für die LEDs
  pinMode (Led_Rot, OUTPUT);
  pinMode (Led_Gruen, OUTPUT);
}
 
void loop () //Hauptprogrammschleife
{
  digitalWrite (Led_Rot, HIGH); // LED wird eingeschaltet
  digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet
  delay (3000); // Wartemodus für 3 Sekunden
 
  digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet
  digitalWrite (Led_Gruen, HIGH); // LED wird eingeschaltet
  delay (3000); // Wartemodus für weitere zwei Sekunden in denen die LEDs dann umgeschaltet sind
}


KY-011_LED_ON-OFF.zip


Codebeispiel PWM

Mittels Puls-Weiten-Modulation [PWM] lässt sich die Helligkeit einer LED regulieren
- dabei wird die LED in bestimmten Zeitintervallen ein und ausgeschaltet, wobei das Verhältnis der Einschalt- und Ausschaltzeit einer relativen Helligkeit entspricht
- aufgrund der Trägheit des menschlichen Sehvermögens, interpretieren die menschlichen Augen ein solches Ein-/Ausschaltverhalten als Helligkeitsänderung.
Nähere Informationen zu diesem Thema finden Sie in diesem [Artikel von mikrokontroller.net].
In diesem Modul sind mehrere LEDs integriert - durch die Überlagerung von unterschiedlichen Helligkeitsstufen lassen sich somit verschiedene Farben kreieren.


Dieses wird im folgenden Codebeispiel gezeigt.

int Led_Rot = 10;
int Led_Gruen = 11;
 
int val;
 
void setup () {
  // Initialisierung Ausgangspins für die LEDs
  pinMode (Led_Rot, OUTPUT);
  pinMode (Led_Gruen, OUTPUT);
}
void loop () {
   // Innerhalb einer For-Schleife werden den beiden LEDs verschiedene PWM-Werte uebergeben
   // Dadurch entsteht ein Farbverlauf, in dem sich durch das Vermischen unterschiedlicher
   // Helligkeitstufen der beiden integrierten LEDs, unterschiedliche Farben entstehen
   for (val = 255; val> 0; val--)
      {
      analogWrite (Led_Gruen, val);
      analogWrite (Led_Rot, 255-val);
      delay (15);
   }
   // In der zweiten For-Schleife wird der Farbverlauf rückwärts durchgegangen
   for (val = 0; val <255; val++)
      {
      analogWrite (Led_Gruen, val);
      analogWrite (Led_Rot, 255-val);
      delay (15);
   }

http://www.linkerkit.de/index.php?title=KY-011_2-Farben_-_Rot%2BGr%C3%BCn-_5mm_LED_Modul

Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf




*********************************************************
3.11   KY-012 - Aktiver Buzzer
Arduino KY-012
Aktives Summermodul - active-buzzer - B
Active Buzzer Module for Arduino
Der aktive Summer ist einfach zu benutzen.
Es müssen nur 5V und GND angelegt werden und schon „summt“ es.
Der Nachteil besteht dabei darin dass man die Tonhöhe nicht beeinflussen kann, nur die Lautstärke.
Hierzu siehe auch den Passiven Summer KY-006
Aktives Summer-Modul KY-012 Arduino-Modul, erzeugt es einen eintonigen Ton, wenn das Signal +5Vdc hoch ist.
Um verschiedene Töne zu erzeugen, verwenden Sie das KY-006 passiv-buzzer-Modul.

-      = GND
Vcc = +5,0V

S     = Signal
Print 18,5x15mm


Der aktive Signalgeber gibt beim Anlegen der Versorgungsspannung von ca. 3V .. 6V bei ca. 16mA einen Ton mit ca. 2,3kHz ab.


Der auf der Oberseite angebrachte Aufkleber muß entfernt werden.
Die Polung ist zu beachten.
Sie ist auf der Platine falsch aufgedruckt.


Piezo-Signalgeber
BlackBoard Circuit Designer Schaltplan

Der Pluspol der Buzzer -Kapsel ist am Modul mit
GND verbunden.
Dies ist aber FALSCH !!!
Der Pluspol muß mit Vcc verbunden werden also Modul-GND nur in diesem Fall mit +5V verbinden ! ! !




https://www.sunfounder.com/learn/sensor_kit_v1_for_Arduino/lesson-12-buzzer-sensor-kit-v1-for-arduino.html



Operating Voltage               3.5V ..5.5V
Maximum Current              30mA / 5Vdc
Resonance Frequency       2500Hz ± 300Hz
Minimum Sound Output      85dB  10cm

Arduino KY-012 Active buzzer module


Buzzer-Modul
Dies ist ein aktiver Summer, so dass seine einfache Verwendung.
Sie geben nur Spannung auf den Summer und es macht Ton.

Nachteil ist, dass man die Frequenz der Töne nicht bestimmen kann, dafür benötigen Sie einen passiven Summer.


Schema

                               Modul-Pin  Minus  = GND 
                Modul-Pin Mitte = n.c
Modul-Pin  S = + 5V

Verbindung zu Arduino
Arduino Digital pin-8        zu  Baugruppenträger S
Arduino           pin-GND   zu  Modul-Pin Minus


Beispielcode für ARDUINO UNO
Sketch KY-012

Die folgende Arduino Sketch schaltet den Summer kontinuierlich EIN und AUS und erzeugt eine Serie kurzer, 2,5kHz Pieptöne.
//Example code KY012 active buzzer

int buzzerPin = 8; void setup () { pinMode (buzzerPin, OUTPUT); } void loop () { digitalWrite (buzzerPin, HIGH); delay (500); digitalWrite (buzzerPin, LOW); delay (500); }

http://arduinomodules.info/ky-012-active-buzzer-module/




//Example code KY012 active buzzer
int speakerPin = 8;

void setup ()
{
pinMode (speakerPin, OUTPUT);
}

void loop ()
{
analogWrite (speakerPin, 255);
delay (50);
analogWrite (speakerPin, 0);
delay (10);
}


https://codebender.cc/sketch:68956#KY-012%20Active%20buzzer%20module.ino



int buzzer=11;

void setup()
{
 pinMode(buzzer,OUTPUT);
}
 
void loop()
{
 unsigned char i,j;
 while(1)
 {
for(i=0;i<80;i++)                 //Output sound of one frequency
 {
  digitalWrite(buzzer,HIGH);      //make a sound
    delay(1);                     //delay 1ms
  digitalWrite(buzzer,LOW);       //silient
 delay(1);                        //delay 1ms
  }
   for(i=0;i<500;i++)//output sound of another frequency
    {
      digitalWrite(buzzer,HIGH);  //make a sound
      delay(2);                   //delay 2ms
      digitalWrite(buzzer,LOW);   //silient
      delay(2);                   //delay 2ms
    }
  }
}
http://learn.linksprite.com/arduino/sensors-kit-for-arduino/ky012-buzzer-module/


int buzzer = 11;           //the pin of the active buzzer

void setup()
{
pinMode(buzzer,OUTPUT);    //initialize the buzzer pin as an output
}

void loop()
{
unsigned char i,j;
while(1)
{
                         //output an frequency
for(i=0;i<80;i++)
{
digitalWrite(buzzer,HIGH);
delay(1);                 //wait for 1ms
digitalWrite(buzzer,LOW);
delay(1);                //wait for 1ms
}
                        //output another frequency
for(i=0;i<100;i++)
{
digitalWrite(buzzer,HIGH);
delay(2);               //wait for 2ms
digitalWrite(buzzer,LOW);
delay(2);              //wait for 2ms
}
}
}


https://www.sunfounder.com/learn/sensor_kit_v1_for_Arduino/lesson-12-buzzer-sensor-kit-v1-for-arduino.html



Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf




*********************************************************
3.12   KY-013 - Analoger Temperatursensor  NTC 4,7k
Arduino KY-013
Temperatursensormodul  - Analog temp

Siehe auch KY-028 mit Komparator daher mit digital Ausgang

Das Temperatursensormodul KY-013 besteht aus einem NTC-Thermistor und einem 10 kΩ-Widerstand.
Der Widerstand des Thermistors variiert mit der Umgebungstemperatur, wir verwenden die Steinhart-Hart-Gleichung, um eine genaue Temperatur des Thermistors abzuleiten.
Genauigkeit +/- 0,5 °C
-      = GND
Vcc = +5,0V

S     = Signal
Print 18,5x15mm


Arduino KY-013 Temperature sensor module
https://tkkrlab.nl/wiki/Arduino_KY-013_Temperature_sensor_module

Es handelt sich um einen ca. 4,7k  NTC (Negativ Temperature Coeicient).
Bei einem negativen Temperaturbeiwert sinkt der Widerstandswert bei steigender Temperatur umgekehrt.
NTCs sind sehr preisgünstig und weisen allerdings keine lineare Widerstandsänderung auf.
Daher ist es eigentlich unumgänglich, den genauen Typ zu kennen, um im Datenblatt (bspw. für den 2381 640 6.472) eine entsprechende Vergleichstabelle zu finden.
Ohne den Typ ist der Sensor wegen Ungenauigkeit fast wertlos.
Alternativ kann man mit einer eigenen Messreihe einiger markanter Temperaturwerte (0 °C, Zimmertemperatur, 100 °C) die Widerstandskurve in etwa interpolieren.
Mit dem zusätzlich verbauten Widerstand wird ein Spannungsteiler realisiert.





Arduino pin-GND   zu Module-Pin minus
Arduino pin-5V+    zu Modul  mittel-Pin  pin 5V
Arduino pin Analog pin-A5  zu  Module S (Signal)

ODER
Pin-mitte = Spannungsteiler NTC+10k   

es gibt aber auch diese Belegung
 

BlackBoard Circuit Designer Schaltplan


NTC Temperatursensor: Widerstand bei Raumtemperatur ca. 10kOhm.
Der NTC Widerstand ist mit den beiden äußeren Pins verbunden.
Zusätzlich ist zwischen dem mittleren Anschluss und dem „S“-Pin noch ein 10kOhm Widerstand auf der Platine enthalten, damit man eine Messbrücke aufbauen kann.
Messbereich: -55°C bis +125°C,
Genauigkeit +/- 0,5°C


Inhalt
    
1 Analoger Temperaturfühler
    
2 Technische Daten
        
2.1 Hardware-Geräte
    
3 Schema

Analoger Temperaturfühler
Zunächst wird das Modul eingeführt
Das Modul basiert auf dem Thermistor (Widerstand erhöht sich mit den Umgebungs-Temperaturänderungen) arbeitet, ein Gefühl von Echtzeit
Um zu wissen, die Temperatur der Umgebungsumgebung verändert, senden wir die Daten an die Arduino Analog IO, dann
Kommen, solange wir durchlaufen Jane Single-Programmierung wird in der Lage, die Sensor-Ausgabedaten Celsius Temperaturwerte umwandeln und angezeigt werden, ist es immer noch einfach zu bedienen,
Erstens effektiv, damit weit verbreitet in Gartenarbeit, Heim-Alarm-Systeme und andere Geräte.

Zweitens ist die Verwendung und der allgemeine Temperatursensor die gleiche, sind drei-line-Paket, wenn wir das Netzkabel angeschlossen OK-Signal-Ausgang In das Ende auf der Linie, weil die Modul-Ausgang ist ein analoges Signal, wollen wir Signal-Ausgang

Das mit der Arduino Analog IO On-Abtastung verbunden ist, um den Temperaturwert korrekt zu lesen;

Bis zu diesem Punkt in der Regel wissen, wie es zu benutzen, dann müssen wir wissen, wie es die nächste Temperaturmessung ist?

Technische Daten
    
Der Temperatursensor ist ein NTC-Thermistor
    
Mehrpunkt-Temperaturmessung Misst Temperaturen: -55 ° C / + 125 ° C
    
Genauigkeit: + / - 0,5 ° C

Hardware-Geräte
    
Arduino Steuergerät × 1
    
USB Datenkabel × 1
    
Das analoge Temperatursensormodul × 1

Wir müssen die oben genannten Dinge testen können, um zu sehen, ob eine Vorlage eine einfache thermische ist, wie man uns hilft, die Temperatur zu messen.

Schema
    
Arduino pin analoog A5  > Modul S (Signal)
    
Arduino Stift GND             >  Modul -
    
Arduino Pin 5+                  > Mittelstift 5,0V

Dieser Code nicht geben die richtigen Werte, in einem Raum, der Art war ok es gab eine Temperatur von 10 °C.
Das ist nicht richtig, so sollte die Berechnung im Code überprüft werden.


Beispielcode für ARDUINO UNO
Sketch KY-03

#include <math.h>
 
int sensorPin = A5; // select the input pin for the potentiometer
 
double Thermistor(int RawADC) {
  double Temp;
  Temp = log(10000.0*((1024.0/RawADC-1))); 
  Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
  Temp = Temp - 273.15;            // Convert Kelvin to Celcius
   //Temp = (Temp * 9.0)/ 5.0 + 32.0; // Convert Celcius to Fahrenheit
   return Temp;
}
 
void setup() {
 Serial.begin(9600);
}
 
void loop() {
 int readVal=analogRead(sensorPin);
 double temp =  Thermistor(readVal);
 
 Serial.println(temp);  // display tempature
 //Serial.println(readVal);  // display tempature
 
 delay(500);
}

https://codebender.cc/sketch:68958#KY-013%20Temperature%20sensor%20module.ino
http://misclab.umeoce.maine.edu/boss/Arduino/bensguides/KeyesKY-013_Analog_Temperature.pdf

http://arduinomodules.info/ky-013-analog-temperature-sensor-module/


Codebeispiel Arduino

Das Programm misst den aktuellen Spannungswert am NTC, berechnet die Temperatur und übersetzt das Ergebnis in °C für die serielle Ausgabe

Modul        Arduino
minus      = pin GND
mitte        = pin 5V+
Signal      = pin-A5


Temperaturmessbereich: -55°C / +125°C
Dieses Modul beinhaltet einen NTC Thermistor—dieser hat bei höherer Temperatur einen immer weniger werdenden Widerstandswert.
Diese Änderung des Widerstands lässt sich mathematisch annähern und in einen linearen Verlauf umrechnen und den Temperaturkoeffizienten (Abhängigkeit von Widerstandsänderung zur Temperaturänderung) bestimmen.
Mittels diesen lässt sich somit dann immer die aktuelle Temperatur errechnen, wenn man den aktuellen Widerstand kennt.
Dieser Widerstand lässt sich mit Hilfe eines Spannungsteilers bestimmen, wo sich eine bekannte Spannung über einen bekannten und einen unbekannten (veränderlichen) Widerstand aufteilt.
Mittels dieser gemessenen Spannung lässt sich dann der Widerstand berechnen - die genaue Berechnung ist in den unten stehenden Codebeispielen enthalten.

#include <math.h>
 
int sensorPin = A5; // Hier wird der Eingangs-Pin deklariert
 
// Diese Funktion übersetzt den aufgenommenen analogen Messwert
// in die entsprechende Temperatur in °C und gibt diesen aus
double Thermistor(int RawADC)
{
    double Temp;
    Temp = log(10000.0 * ((1024.0 / RawADC - 1)));
    Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp )) * Temp );
    Temp = Temp - 273.15;            // Konvertierung von Kelvin in Celsius
    return Temp;
}
 
// Serielle Ausgabe in 9600 Baud
void setup()
{
    Serial.begin(9600);
}
 
// Das Programm misst den aktuellen Spannungswert am NTC
// und übersetzt das Ergebnis in °C für die serielle Ausgabe
void loop()
{
    int readVal = analogRead(sensorPin);
    double temp =  Thermistor(readVal);
 
    // Ausgabe auf die serielle Schnittstelle
    Serial.print("Aktuelle Temperatur ist:");
    Serial.print(temp);
        Serial.print(char(186)); //Ausgabe <°> Symbol
    Serial.println("C");
    Serial.println("---------------------------------------");
 
    delay(500);
}


KY-013_TemperaturSensor.zip

http://www.linkerkit.de/index.php?title=KY-013_Temperatur-Sensor_Modul




einfache schaltung digitaler temperatursensor modul und integrierte LED anschluss, um digitale 13 schnittstelle, um temperatur kontrollleuchte.
verwenden nummer 13 zu verbinden die integrierte LED, verbinden digitale temperatursensor bis nummer 3 schnittstelle. wenn die digitale temperatursensor sinne schlüssel signal, die LED ist auf, andernfalls, es ist aus.
probe code:


Int Led = 13;//definieren FÜHRTE schnittstelle
Int buttonpin = 3;//definieren die digitale temperatursensor schnittstelle
Int val.//definieren digitale variable val
leere setup ()
{
PinMode (Led, die AUSGANG);//definieren die LED für die ausgangsschnittstelle
PinMode (buttonpin, EINGANG);//definieren die digitale temperatursensor für der ausgangsschnittstelle
}
leere loop ()
{
Val = digitalRead (buttonpin);//zuzuweisen den wert der digitalen schnittstelle 3 lesen val
wenn (val = = HOHE)//wenn digitale temperatur sensor detection signal, LED blinkt
{
DigitalWrite (Led, HOHE);
}
die sonst
{
DigitalWrite (Led, LOW);
}
}


https://de.aliexpress.com/item/F-r-Arduino-AVR-PIC-DIY-Maker-BOOOLE-Ky-028-Digitale-Temperatursensormodul/32674019660.html



Einige KY-013-Karten sind falsch gekennzeichnet, wenn Sie invertierte Werte erhalten (Temperaturabsenkung bei geheiztem Sensor),
 tauschen Sie Signal (S) und Masse (-) aus.

Bei meinem Modul ist der mittlere Pin auf pin-A0 zu verbinden (blau und rot daher kreuzen)





KY-013 Beispielcode

Die folgende Arduino-Skizze leitet die Temperatur des Thermistors mit Hilfe der in der Funktion Thermister implementierten Steinhart-Hart-Gleichung ab.


#include <math.h>

double Thermister(int RawADC) {
	double Temp;
	Temp = log(((10240000/RawADC) - 10000));
	Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp ))* Temp );
	Temp = Temp - 273.15; // Convert Kelvin to Celcius
	return Temp;
}

void setup() {
	Serial.begin(9600);
}

void loop() {
	Serial.print(Thermister(analogRead(0))); //read pin A0
	Serial.println("c");
	delay(500);
}

http://arduinomodules.info/ky-013-analog-temperature-sensor-module/

Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf




*********************************************************
3.13   KY-015 - Digitaler Temperatur- und Luftfeuchtigkeitssensor
Arduino KY-015
Temperatur- und Feuchte-Messmodul - Temp and humidity
Arduino KY-015 Temperatur- und FeuchtigkeitsSensorModul
mit SENSOR DHT-11 (DHT-21  DHT-22 = AM2302)
https://arduino-info.wikispaces.com/DHT11-Humidity-TempSensor
http://playground.arduino.cc/Main/DHT11Lib
http://playground.arduino.cc/Main/DHTLib
http://www.arduino.org/learning/tutorials/boards-tutorials/dht11-temperature-and-humidity-sensor-example
http://www.instructables.com/id/How-to-interface-Humidity-and-Temperature-DTH11-Se/
https://www.bastelgarage.ch/index.php?route=blog/post/view&blog_post_id=3


DHT11-Humidity-TempSensor

https://arduino-info.wikispaces.com/DHT11-Humidity-TempSensor



Der integrierte Sensor DHT11 kann die Temperatur und Luftfeuchtigkeit in einem eigenen einfachen 1-Draht-Protokoll alle 2 Sekunden liefern.
Betriebsspannung: 3,5 bis 5,5 V
Temperaturmessbereich: -40 bis +80 °C (ca. ±2 °C)
Luftfeuchtigkeit: 0 bis 100% (ca. ±5%)

Für die Datenleitung, die bis zu 20m lang sein kann, wird ein Pull-Up-Widerstand benötigt, der bereits auf dem Modul vorhanden ist.
Zu beachten ist, dass die Module DHT21 und  DHT22 auf die gleiche Weise funktionieren aber die Messwertberechnung sich unterscheidet.




-      = GND
Vcc = +5,0V

S     = Signal
Print 18,5x17mm

BlackBoard Circuit Designer Schaltplan

Es gibt aber auch
Vcc = +5,0V
S     =  Data
-      = GND




Arduino KY-015 Temperature and humidity sensor module
Temperatur-/Luftfeuchtigkeitssensor auf Platine,
Typ: DHT11,
Temp.: 0 - 50°C (+/-2°C), rel.
Feuchte: 20-95% (+/-5%),
Spannungsversorgung: 3-5,5V.
Eingebauter 10k Ohm pull-up Widerstand.

Inhalt
1 Digitales Temperatur- und Feuchtesensormodul
2 Die Modulbezogenen Präsentationen
   2.1 Technische Daten
   2.2 Hinweise
3 Verwendung
   3.1 Schematische Darstellung
   3.2 Hardwareanforderungen
4 Beispielcode

Digitales Temperatur- und Feuchtesensor Modul
DHT11 digitale Temperatur-und Feuchte-Sensor ist eine kalibrierte digitale Signalausgang Temperatur und Luftfeuchtigkeit kombiniert Sensor, die Application-spezifische Module erfassen Technologie und digitale Temperatur-und Feuchte-Sensor-Technologie, um sicherzustellen, dass Produkte mit hoher Zuverlässigkeit und exzellente Langzeitstabilität.
Das Modul hat ausgezeichnete Qualität, schnelle Antwort, Anti-Interferenz-Fähigkeit, hohe Kosten und andere Vorteile.
Single Wire serielle Schnittstelle, die eine schnelle und einfache Systemintegration ermöglicht.
Ultra-kleine Baugröße, geringer Stromverbrauch, Signalübertragungsdistanz
Bis zu 20 Meter, so dass es für die Klasse der Anwendungen und sogar die anspruchsvollsten Anwendungen ist die beste Wahl.
Produkte für die 4-polige einreihige Pin-Paket, einfache Verbindung.

Technische Daten
Versorgungsspannung:  3,3 .. 5,5Vdc
Ausgang:                     Einzelbus Digitalsignal
Messbereich:
 Luftfeuchtigkeit 20-90% RH,
 Temperatur 0 ~ 50 ℃
Genauigkeit:
 Luftfeuchtigkeit + -5% RH,
 Temperatur + -2 ℃
Auflösung:
 Luftfeuchtigkeit 1% rF,
 Temperatur 1 ℃
Langzeitstabilität: <± 1% RH / Jahr

Notizen
Um die Verwendung der Kondensationsbedingungen zu vermeiden, Langfristige Lagertemperatur 10..40 ℃, Luftfeuchtigkeit unter 60%
Wobei der Strom und der Masseanschluss korrekt sind, um den Sensor nicht zu beschädigen

Benutzen
Über DHT11 spezifische Timing-Probleme können wir auf seine Datenblatt beziehen, siehe die folgenden Module, wie unsere Firma Er verbunden mit dem Arduino-Board

Schema
Arduino GND zu Pin-minus Modul
Arduino +5V zu Pin Mitte
Arduino pin-8 zu Pin-S Modul

Hardware-Anforderungen
Arduino UNO R3
USB Datenkabel
DHT-11 Modul


Beispielcode für ARDUINO UNO
Sketch KY-015

//KY015 DHT11 Temperature and humidity sensor 
int DHpin = 8;
byte dat [5];
byte read_data () {
  byte data;
  for (int i = 0; i < 8; i ++) {
    if (digitalRead (DHpin) == LOW) {
      while (digitalRead (DHpin) == LOW); // wait for 50us
      delayMicroseconds (30); // determine the duration of the high level to determine the data is '0 'or '1'
      if (digitalRead (DHpin) == HIGH)
        data |= (1 << (7-i)); // high front and low in the post
      while (digitalRead (DHpin) == HIGH); // data '1 ', wait for the next one receiver
     }
  }
return data;
}
 
void start_test () {
  digitalWrite (DHpin, LOW); // bus down, send start signal
  delay (30); // delay greater than 18ms, so DHT11 start signal can be detected
 
  digitalWrite (DHpin, HIGH);
  delayMicroseconds (40); // Wait for DHT11 response
 
  pinMode (DHpin, INPUT);
  while (digitalRead (DHpin) == HIGH);
  delayMicroseconds (80); // DHT11 response, pulled the bus 80us
  if (digitalRead (DHpin) == LOW);
  delayMicroseconds (80); // DHT11 80us after the bus pulled to start sending data
 
  for (int i = 0; i < 4; i ++) // receive temperature and humidity data, the parity bit is not considered
    dat[i] = read_data ();
 
  pinMode (DHpin, OUTPUT);
  digitalWrite (DHpin, HIGH); // send data once after releasing the bus, wait for the host to open the next Start signal
}
 
void setup () {
  Serial.begin (9600);
  pinMode (DHpin, OUTPUT);
}
 
void loop () {
  start_test ();
  Serial.print ("Current humdity =");
  Serial.print (dat [0], DEC); // display the humidity-bit integer;
  Serial.print ('.');
  Serial.print (dat [1], DEC); // display the humidity decimal places;
  Serial.println ('%');
  Serial.print ("Current temperature =");
  Serial.print (dat [2], DEC); // display the temperature of integer bits;
  Serial.print ('.');
  Serial.print (dat [3], DEC); // display the temperature of decimal places;
  Serial.println ('C');
  delay (700);
}
https://tkkrlab.nl/wiki/Arduino_KY-015_Temperature_and_humidity_sensor_module


Beschreibung

KY-015 Arduino Temperatur- und Feuchtemessmodul bietet eine digitale serielle Schnittstelle zur Messung von Feuchtigkeit und Temperatur.


KY-015 Technische Daten
Dieses Modul besteht aus einem digitalen Feuchte- und Temperatursensor DHT11
und einem 1 kΩ-Widerstand.
Der DHT11 nutzt einen internen Thermistor und einen kapazitiven Feuchtesensor zur Ermittlung der Umgebungsbedingungen,
ein interner Chip ist verantwortlich für die Umwandlung von Messwerten in ein serielles Digitalsignal.
Betriebsspannung                        3.3V bis 5.5V
Feuchtemessbereich                   20% bis 90% RH
Feuchtigkeitsmessgenauigkeit     ± 5% RH
Feuchtigkeitsmessauflösung        1% rF
Temperaturmessbereich             0ºC bis 50ºC [32ºF bis 122ºF]
Temperaturmessgenauigkeit       ± 2ºC
Temperaturmessauflösung        1 ° C
Signalübertragungsbereich        20m


KY-015 Anschlussplan

Verbinden Sie die Netzleitung (Mitte) und Masse (-) mit +5 bzw. GND. Verbinden Sie Signal (S) mit Pin 8 auf dem Arduino.

KY-015                              Arduino
S                                      pin-8
Mitte                                 + 5V
minus                                GND


KY-015 Arduino-Code
Die folgende Sketch verwendet pin-8 auf dem Arduino, um seriell Daten vom KY-015-Sensor zu senden und zu empfangen.
Die serielle Kommunikation wird durch Senden spezifischer High / Low-Signale an den Sensor und Warten auf eine Antwort archiviert.
Temperatur- und Feuchtigkeitsdaten werden bitweise gelesen und als Array von Bytes zurückgegeben.

int DHpin = 8; // input/output pin
byte dat[5];   

byte read_data()
{
	byte data;
	for(int i = 0; i < 8; i++)
	{
		if(digitalRead(DHpin) == LOW)
		{
			while(digitalRead(DHpin) == LOW); // wait 50us;
			delayMicroseconds(30); //The duration of the high level is judged to determine whether the data is '0' or '1';
			if(digitalRead(DHpin) == HIGH)
				data |= (1<<(7 - i)); //High in the former, low in the post;
			while(digitalRead(DHpin) == HIGH); //Data '1', waiting for the next bit of reception;
		}
	}
	return data;
}

void start_test()
{
	digitalWrite(DHpin, LOW); //Pull down the bus to send the start signal;
	delay(30); //The delay is greater than 18 ms so that DHT 11 can detect the start signal;
	digitalWrite(DHpin, HIGH);
	delayMicroseconds(40); //Wait for DHT11 to respond;
	pinMode(DHpin, INPUT);
	while(digitalRead(DHpin) == HIGH);
	delayMicroseconds(80); //The DHT11 responds by pulling the bus low for 80us;
	if(digitalRead(DHpin) == LOW);
		delayMicroseconds(80); //DHT11 pulled up after the bus 80us to start sending data;
	for(int i = 0; i < 4; i++) //Receiving temperature and humidity data, check bits are not considered;
		dat[i] = read_data();
	pinMode(DHpin, OUTPUT);
	digitalWrite(DHpin, HIGH); //After the completion of a release of data bus, waiting for the host to start the next signal
}

void setup()
{
	Serial.begin(9600);
	pinMode(DHpin, OUTPUT);
}

void loop()
{
	start_test();
	Serial.print("Current humdity = ");
	Serial.print(dat[0], DEC); //Displays the integer bits of humidity;
	Serial.print('.');
	Serial.print(dat[1], DEC); //Displays the decimal places of the humidity;
	Serial.println('%');
	Serial.print("Current temperature = ");
	Serial.print(dat[2], DEC); //Displays the integer bits of temperature;
	Serial.print('.');
	Serial.print(dat[3], DEC); //Displays the decimal places of the temperature;
	Serial.println('C');
	delay(700);
}

http://arduinomodules.info/ky-015-temperature-humidity-sensor-module/
http://www.instructables.com/id/Arduino-Temp-and-Humidity-DHT11-LCD-1602A-KY-015-S/
http://www.ram-e-shop.com/ds/general/KY-015.pdf
https://codebender.cc/sketch:68964#KY-015%20Temperature%20and%20humidity%20sensor%20module.ino
http://fritzing.org/projects/termometar-with-ky-015-sensor
http://www.linkerkit.de/index.php?title=KY-015_Kombi-Sensor_Temperatur%2BFeuchtigkeit

Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf


DHT11 Class for Arduino UNO r3


Usage

A sketch shows how the library can be used to read the sensor:

// 
//   FILE:  dht11_test1.pde
// PURPOSE: DHT11 library test sketch for Arduino
//

//Celsius to Fahrenheit conversion
double Fahrenheit(double celsius)
{
	return 1.8 * celsius + 32;
}

// fast integer version with rounding
//int Celcius2Fahrenheit(int celcius)
//{
//  return (celsius * 18 + 5)/10 + 32;
//}


//Celsius to Kelvin conversion
double Kelvin(double celsius)
{
	return celsius + 273.15;
}

// dewPoint function NOAA
// reference (1) : http://wahiduddin.net/calc/density_algorithms.htm
// reference (2) : http://www.colorado.edu/geography/weather_station/Geog_site/about.htm
//
double dewPoint(double celsius, double humidity)
{
	// (1) Saturation Vapor Pressure = ESGG(T)
	double RATIO = 373.15 / (273.15 + celsius);
	double RHS = -7.90298 * (RATIO - 1);
	RHS += 5.02808 * log10(RATIO);
	RHS += -1.3816e-7 * (pow(10, (11.344 * (1 - 1/RATIO ))) - 1) ;
	RHS += 8.1328e-3 * (pow(10, (-3.49149 * (RATIO - 1))) - 1) ;
	RHS += log10(1013.246);

        // factor -3 is to adjust units - Vapor Pressure SVP * humidity
	double VP = pow(10, RHS - 3) * humidity;

        // (2) DEWPOINT = F(Vapor Pressure)
	double T = log(VP/0.61078);   // temp var
	return (241.88 * T) / (17.558 - T);
}

// delta max = 0.6544 wrt dewPoint()
// 6.9 x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
	double a = 17.271;
	double b = 237.7;
	double temp = (a * celsius) / (b + celsius) + log(humidity*0.01);
	double Td = (b * temp) / (a - temp);
	return Td;
}


#include <dht11.h>

dht11 DHT11;

#define DHT11PIN 2

void setup()
{
  Serial.begin(115200);
  Serial.println("DHT11 TEST PROGRAM ");
  Serial.print("LIBRARY VERSION: ");
  Serial.println(DHT11LIB_VERSION);
  Serial.println();
}

void loop()
{
  Serial.println("\n");

  int chk = DHT11.read(DHT11PIN);

  Serial.print("Read sensor: ");
  switch (chk)
  {
    case DHTLIB_OK: 
		Serial.println("OK"); 
		break;
    case DHTLIB_ERROR_CHECKSUM: 
		Serial.println("Checksum error"); 
		break;
    case DHTLIB_ERROR_TIMEOUT: 
		Serial.println("Time out error"); 
		break;
    default: 
		Serial.println("Unknown error"); 
		break;
  }

  Serial.print("Humidity (%): ");
  Serial.println((float)DHT11.humidity, 2);

  Serial.print("Temperature (°C): ");
  Serial.println((float)DHT11.temperature, 2);

  Serial.print("Temperature (°F): ");
  Serial.println(Fahrenheit(DHT11.temperature), 2);

  Serial.print("Temperature (°K): ");
  Serial.println(Kelvin(DHT11.temperature), 2);

  Serial.print("Dew Point (°C): ");
  Serial.println(dewPoint(DHT11.temperature, DHT11.humidity));

  Serial.print("Dew PointFast (°C): ");
  Serial.println(dewPointFast(DHT11.temperature, DHT11.humidity));

  delay(2000);
}
//
// END OF FILE
//



http://playground.arduino.cc/Main/DHT11Lib



Programm / Sketch  um Temperatur- und Feuchtigkeitsdaten auf SD-Karte zu schreiben
Der Sketch  zeichnet alle 30 sek die aktuellen Daten auf ne SD mit meinem Mega2560 und dem W5100.
Den DHT hab ich nur draufgesteckt und benutze die Ports des Mega als Spannungsversorgung.

http://learn.adafruit.com/adafruit-data-logger-shield

x715_d_FRANZIS-x_20344-9 Sensoren am Arduino - BUCH (216 Seiten)_1a.pdf

/*
  SD card Temp & Humidity datalogger

This example shows how to log data from
a DHT11 temperature and humidity sensor
to an SD card using the SD library.

It also uses the Adafruit DHT sensor library from
https://github.com/adafruit/DHT-sensor-library
    
The circuit:
* SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 53
* DHT11 sensor connected as follows:
** Ground connected to 5
** Voltage connected to 8
** data out connected to 7
** 10K resistor connected from 7 to +5V


*/

#include <SD.h>
#include "DHT.h"
#include <Time.h>  
#include <Wire.h>  
#include <DS1307RTC.h>

#define DHTPIN 24        // what pin the sensor is connected to
#define DHTTYPE DHT11   // Which type of DHT sensor you're using:
#define DHT_GND 26       // ground pin of the sensor
#define DHT_VCC 22       // voltage pin of the sensor
#define TEMPERATURE 1   //  for the DHT sensor
#define HUMIDITY 0      // for the DHT sensor
#define fehler 13

// initialize the sensor:
DHT dht(DHTPIN, DHTTYPE);
// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 53; // 4,10,53

void setup() {
  pinMode(fehler, OUTPUT);
  setSyncProvider(RTC.get);   // the function to get the time from the RTC

  if (startSDCard() == true) {
    pinMode(DHT_VCC, OUTPUT);
    pinMode(DHT_GND, OUTPUT);
    digitalWrite(DHT_VCC, HIGH);
    digitalWrite(DHT_GND, LOW);
    dht.begin();
  }
}

void loop()
{
  // Get the current time in ms:

  long currentTime = millis();
  delay(29250);// normalmodus
//  delay(250); //test schnelle ergebnisse
  digitalWrite(fehler, HIGH);
  delay(250);
  digitalWrite(fehler, LOW);
  delay(250);
  digitalWrite(fehler, HIGH);
  delay(250);
  digitalWrite(fehler, LOW);
  float humidity = readSensor (HUMIDITY);
  float temperature = readSensor(TEMPERATURE);
  File dataFile = SD.open("datalog.csv", FILE_WRITE);
  dataFile.print(humidity);
  dataFile.print(";");
  dataFile.println(temperature);
  dataFile.print("; ");
  dataFile.print(day());
  dataFile.print(":");
  dataFile.print(month());
  dataFile.print(":");
  dataFile.print(year());
  dataFile.print("; ");
  dataFile.print(hour());
  dataFile.print(":");
  dataFile.print(minute());
  dataFile.print(":");
  dataFile.print(second());
  dataFile.print("; ");

  dataFile.close();

}


boolean startSDCard() {
  boolean result = false;
  // Serial.print("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(53, OUTPUT);

  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    result = false;
  }
  else {
      File dataFile = SD.open("datalog.csv", FILE_WRITE);
    if (dataFile) {
      dataFile.close();
      result = true;
    }
  }  
  return result;
}


float readSensor( int thisValue) {
  float result;

  if (thisValue == TEMPERATURE) {
    result = dht.readTemperature();
  }
  else if (thisValue == HUMIDITY) {
    // read sensor:
    result = dht.readHumidity();  
  }

  if (isnan(result)) {
     result = -273.0;
  }
  return result;
}


https://www.arduinoforum.de/arduino-Thread-Programm-um-Temperatur-und-Feuchtigkeitsdaten-auf-Sd-Karte-zu-schreiben



In diesem Post geht es darum, wie man den DHT11 Temperatur und Luftfeuchtigkeitssensor mit dem Arduino verbindet und ausließt. Dadurch erhält man die genaue aktuelle Temperatur und Luftfeuchtigkeit.

Dieser Post ist Teil der Artikelserie über das Ultimate Arduino Sensor Kit mit 37 Sensoren. Das Kit, inklusiv DHT11, gibt es hier auf Amazon. Den Temperatur und Luftfeuchtigkeitssensor einzeln findet ihr hier auf Amazon.
Die Verbindung des Sensors mit dem Arduino gestaltet sich denkbar einfach. Abgesehen vom Ground (rechter Pin) und +5V (mittlerer Pin), muss man nur den linken Pin als Datenleitung mit dem Arduino verbinden. Im unteren Beispielsketch wird Pin 2 verwendet, man kann jedoch auch einen beliebigen Anderen verwenden.

Um den DHT11 auszulesen, gibt es die dht11 Bibliothek. Diese muss man sich jedoch erst "zusammen basteln". Dazu muss man im libraries Unterordner eures Arduino Ordners der Arduino IDE, einen Ordner namens "dht11" erstellen. In diesem Ordner müsst ihr nun über den Windows Editor zwei Dateien erstellen: dht11.h und dht11.cpp . Den Quellcode für beide Dateien findet ihr hier.

Ihr müsst unbedingt darauf achten, dass die Datein auch wirklich die passende Dateiendung und nicht .txt haben. Dann erscheint nach einem Neustart eurerer Arduino IDE auch die neue dht11 Bibliothek.

Zu dieser gibt es auch schon einen Beispielsketch, mithilfe dessen ihr einen DHT11 Sensor, angeschlossen an Pin 2 des Arduino, auslesen könnt.

Um einen anderen Pin zu verwenden, müsst ihr einfach nur die Zeile #define DHT11PIN ändern. Jetzt bekommt ihr nach dem Upload des Sketches die aktuelle Temperatur und Luftfeuchtigkeit in der seriellen Konsole (Baudrate 115200) angezeigt.

Um das Auslesen zu vereinfachen, damit euer eigentlicher Sketch nicht zu groß wird, könnt ihr einfach die Umrechenfunktionen von Grad Celsius in Grad Fahrenheit und Kelvin löschen. Auch die Berechnung des Taupunkts, also ab welcher Temperatur sich mit der gemessenen Luftfeuchtigkeit Tau bilden würde, ist oft uninteressant. Dadurch wird der Sketch wesentlich kleiner.

DHT11_example.ino hosted with ❤ by GitHub


//
// FILE: dht11_test1.pde
// PURPOSE: DHT11 library test sketch for Arduino
//

//Celsius to Fahrenheit conversion
double Fahrenheit(double celsius)
{
return 1.8 * celsius + 32;
}

// fast integer version with rounding
//int Celcius2Fahrenheit(int celcius)
//{
// return (celsius * 18 + 5)/10 + 32;
//}


//Celsius to Kelvin conversion
double Kelvin(double celsius)
{
return celsius + 273.15;
}

// dewPoint function NOAA
// reference (1) : http://wahiduddin.net/calc/density_algorithms.htm
// reference (2) : http://www.colorado.edu/geography/weather_station/Geog_site/about.htm
//
double dewPoint(double celsius, double humidity)
{
// (1) Saturation Vapor Pressure = ESGG(T)
double RATIO = 373.15 / (273.15 + celsius);
double RHS = -7.90298 * (RATIO - 1);
RHS += 5.02808 * log10(RATIO);
RHS += -1.3816e-7 * (pow(10, (11.344 * (1 - 1/RATIO ))) - 1) ;
RHS += 8.1328e-3 * (pow(10, (-3.49149 * (RATIO - 1))) - 1) ;
RHS += log10(1013.246);

// factor -3 is to adjust units - Vapor Pressure SVP * humidity
double VP = pow(10, RHS - 3) * humidity;

// (2) DEWPOINT = F(Vapor Pressure)
double T = log(VP/0.61078); // temp var
return (241.88 * T) / (17.558 - T);
}

// delta max = 0.6544 wrt dewPoint()
// 6.9 x faster than dewPoint()
// reference: http://en.wikipedia.org/wiki/Dew_point
double dewPointFast(double celsius, double humidity)
{
double a = 17.271;
double b = 237.7;
double temp = (a * celsius) / (b + celsius) + log(humidity*0.01);
double Td = (b * temp) / (a - temp);
return Td;
}


#include <dht11.h>

dht11 DHT11;

#define DHT11PIN 2

void setup()
{
Serial.begin(115200);
Serial.println("DHT11 TEST PROGRAM ");
Serial.print("LIBRARY VERSION: ");
Serial.println(DHT11LIB_VERSION);
Serial.println();
}

void loop()
{
Serial.println("\n");

int chk = DHT11.read(DHT11PIN);

Serial.print("Read sensor: ");
switch (chk)
{
case DHTLIB_OK:
Serial.println("OK");
break;
case DHTLIB_ERROR_CHECKSUM:
Serial.println("Checksum error");
break;
case DHTLIB_ERROR_TIMEOUT:
Serial.println("Time out error");
break;
default:
Serial.println("Unknown error");
break;
}

Serial.print("Humidity (%): ");
Serial.println((float)DHT11.humidity, 2);

Serial.print("Temperature (°C): ");
Serial.println((float)DHT11.temperature, 2);

Serial.print("Temperature (°F): ");
Serial.println(Fahrenheit(DHT11.temperature), 2);

Serial.print("Temperature (°K): ");
Serial.println(Kelvin(DHT11.temperature), 2);

Serial.print("Dew Point (°C): ");
Serial.println(dewPoint(DHT11.temperature, DHT11.humidity));

Serial.print("Dew PointFast (°C): ");
Serial.println(dewPointFast(DHT11.temperature, DHT11.humidity));

delay(2000);
}
//
// END OF FILE
//
















*********************************************************
3.14   KY-016 - RGB-LED
Arduino KY-016
3-farbiges LED-Modul - RGB LED 5mm
3 Farben - farbenreiches LED-Modul



Bei meinem Modul ist die Pinbelegung so

-  GND  LED-Kathode
B = Blau
G = Grün
R = Rot

Print 18,5x17mm


BlackBoard Circuit Designer Schaltplan

Die 5 mm LED enthält im Prinzip drei LEDs in den Farben Rot, Grün und Blau mit einer gemeinsamen Kathode.
Für jede LED ist ein eigener Vorwiderstand 150R  für 5V Betrieb schon vorhanden.

Arduino KY-016 3-color LED module

RGB LED mit klarem Gehäuse und eingebauten Vorwiderständen (je 150 Ohm) für 5V-Betrieb.
Die LED hat eine gemeinsame Kathode (- Pol).

Inhalt
1. Übersicht
2 Technische Daten
3 Schema
4 Beispielcode
5 Einfache Demo ohne Kabel
Beispielcode zufällig

Überblick
RGB-LED-Modul besteht aus einem Plug-in Vollfarb-LED von R, G, B drei Pin PWM-Spannungseingang angepasst werden können Sektion drei Primärfarben (rot / blau / grün) Stärke, um vollen Farbmischung Effekt zu erzielen.

Technische Daten
Die Verwendung von Plug-in Vollfarb-LED
RGB trichromatischen Begrenzungswiderstand zu verhindern Burnout
Durch die PWM-Einstellung können drei Grundfarben gemischt werden, um unterschiedliche Farben zu erhalten
Mit einer Vielzahl von Single-Chip-Schnittstelle
Die Arbeitsspannung: 5V
LED-Modus: gemeinsamer Kathoden-Treiber


Schema
Arduino pin-GND    zu    Pin-minus Modul  (gem. LED-Kathode)
 Arduino pin-11       zu    Pin-R Modul
Arduino pin-10       zu    Pin-G Modul
Arduino pin-9         zu    Pin-B Modul


Sie benötigen keine Widerstände, diese sind bereits im Modul enthalten.


Beispielcode für ARDUINO UNO
Sketch KY-016

//KY016 3-color LED module
int redpin = 11; // select the pin for the red LED
int bluepin = 10; // select the pin for the blue LED
int greenpin = 9 ;// select the pin for the green LED
int val;
void setup () {
  pinMode (redpin, OUTPUT);
  pinMode (bluepin, OUTPUT);
  pinMode (greenpin, OUTPUT);
  Serial.begin (9600);
}
void loop ()
{
  for (val = 255; val> 0; val --)
  {
    analogWrite (11, val);
    analogWrite (10, 255-val);
    analogWrite (9, 128-val);
    delay (10);
    Serial.println (val, DEC);
  }
  for (val = 0; val <255; val ++)
  {
    analogWrite (11, val);
    analogWrite (10, 255-val);
    analogWrite (9, 128-val);
    delay (10);
    Serial.println (val, DEC);
  }
}




Einfacher Aufbau ohne Kabel

/*
Demo für KY-009 und KY-016.
  Stecken Sie die Platine direkt in Ihr Arduino Board ein, ohne es zu benutzen
  Leitungen. Wenn Sie die Karte um 180 ° drehen, sollten Sie Pin 12 verwenden
  Boden und tauschen Sie die grüne und blaue Stift.
  Die Demo wird im Laufe der Zeit Zyklus durch alle 16777216
  Verschiedene Farben, die mit 3x8bit gemacht werden können.
*/
int groundpin = 8; // write 0 to get ground int greenpin = 9; // select the pin for the green LED int redpin = 10; // select the pin for the red LED int bluepin = 11; // select the pin for the blue LED   void setup () { pinMode (redpin, OUTPUT); pinMode (greenpin, OUTPUT); pinMode (bluepin, OUTPUT); pinMode (groundpin, OUTPUT); digitalWrite (groundpin, LOW); }   void loop () { analogWrite (redpin, random(255)); analogWrite (greenpin, random(255)); analogWrite (bluepin, random(255)); delay (300);
}

https://tkkrlab.nl/wiki/Arduino_KY-016_3-color_LED_module




Arduino - Rotary encoder Simple Example KY-040



http://www.instructables.com/id/Arduino-Rotary-Encoder-Simple-Example-KY-040/


http://www.instructables.com/id/Arduino-Touch-Sensor-Switch-Using-the-KY-036/


https://cdn-learn.adafruit.com/downloads/pdf/adafruit-arduino-lesson-3-rgb-leds.pdf
https://learn.adafruit.com/adafruit-arduino-lesson-3-rgb-leds/arduino-sketch
http://playground.arduino.cc/Main/RGBLEDPWM
http://funduino.de/nr-20-rgb-led
https://arduino-info.wikispaces.com/RGB-LED
http://www.makerblog.at/2014/09/eine-rgb-led-am-arduino-betreiben/
http://www.instructables.com/id/RGB-LED-Tutorial-using-an-Arduino-RGBL/
https://learn.sparkfun.com/tutorials/sik-experiment-guide-for-arduino---v32/experiment-3-driving-an-rgb-led
https://gist.github.com/jamesotron/766994
https://www.apfelkern.info/rgb-led-mit-arduino-zum-leuchten-bringen/
http://www.tested.com/art/makers/453665-how-get-started-programmable-rgb-led-strip-lighting/



Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf





*********************************************************
3.15   KY-017 - Quecksilberschalter
Arduino KY-017
Quecksilber-Schalter & SMD-LED - Tilt switch
                       Dieses Modul ist in Europa verboten ! ! !
Mercury switch



2x Arduino KY-027 Quecksilber-Schalter & 5mm-LED - Light Cup
                       Diese 2 Module sind in Europa verboten ! ! !
Die Verwendung von Quecksilber in elektronischen Bauteilen ist nicht mehr erlaubt.
Quecksilber birgt für Mensch und Umwelt Gefahren und ist gesundheitsschädlich.
Achten Sie darauf, dass das Glasröhrchen nicht beschädigt wird.
Wenn Quecksilber ausgetreten ist, verlassen Sie den Raum und informieren Sie sich über die gefahrlose Beseitigung.
Das Bauteil darf nicht im Hausmüll entsorgt werden, sondern gilt als Sondermüll.
Das Modul ist nicht für Kinder geeignet.



Besser Sie verwenden das
Arduino KY-020 Kippschaltermodul - Ball switch - Kugelschalter

Quecksilber-Schalter, der bei Neigen oder Kippen einen Kontakt herstellt bzw. öffnet.
Es handelt sich um einen Quecksilberschalter mit einem digitalen Interface, mit dem eine einfache Schaltung für eine Tilt (=Schlag) Warnung ausgegeben werden kann.
Wird der Quecksilberschalter bewegt und schaltet, leuchtet die LED


S     = Signal
Vcc = +5,0V
-      = GND
Print 18,5x17mm

Bei dem Modul handelt es sich um einen klassischen Neigungsschalter mit Quecksilbertropfen.
Quecksilber ist leitfähig, benetzt nicht das Glas und bildet aufgrund seiner starken Kohäsion einen Tropfen.
Wird der Glaszylinder geneigt, rollt der Tropfen im Glas umher.
Befindet er sich im unteren Bereich, schließt er die beiden Anschlüsse kurz.
Ein Quecksilberschalter ist absolut verschleißfrei.


BlackBoard Circuit Designer Schaltplan

http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/keyes-ky-017-arduino-mercury-tilt-switch-tutorial/



Arduino KY-017 Mercury open optical module

Quecksilber-Schalter-Modul und eine digitale Schnittstelle, eingebaute pin-13 LED
Kipp-Warnlampe pin-13 kommt mit digitalen Schnittstellen der LED, die Quecksilber-Kippschalter Sensor-Schnittstelle auf digitalen 3 zugreifen, wenn der Kippschalter Sensor eine Taste erkennt Signal, LED pin-13  leuchtet, andernfalls aus.





Beispielcode für ARDUINO UNO
Sketch KY-017

//KY017 Mercury open optical module
int Led = 13 ;// define LED Interface
int buttonpin = 3; // define the mercury tilt switch sensor interface
int val ;// define numeric variables val
void setup ()
{
  pinMode (Led, OUTPUT) ;// define LED as output interface
  pinMode (buttonpin, INPUT) ;// define the mercury tilt switch sensor output interface
}
void loop ()
{
  val = digitalRead (buttonpin) ;// read the values assigned to the digital interface 3 val
  if (val == HIGH) // When the mercury tilt switch sensor detects a signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}

https://tkkrlab.nl/wiki/Arduino_KY-017_Mercury_open_optical_module


Magic Light Cup-Module sind einfach zu Interactive Technology Division entwickelt eine Dose und ARDUINO interaktive Module, PWM Dimmen Prinzip ist es, das Prinzip der zwei Module Helligkeitsänderungen zu verwenden. Quecksilberschalter stellen ein digitales Signal zur Verfügung, das den PWM Regler auslöst, durch das Programmentwurf,
Wir können das Licht wie zwei Schalen sehen, die mit der Wirkung des shuffling hin und her gefüllt werden.


int LedPinA = 5;
int LedPinB = 6;
int ButtonPinA = 7;
int ButtonPinB = 4;
int buttonStateA = 0;
int buttonStateB = 0;
int brightness = 0;

void setup() { pinMode(LedPinA, OUTPUT); pinMode(LedPinB, OUTPUT); pinMode(ButtonPinA, INPUT); pinMode(ButtonPinB, INPUT); } void loop() { buttonStateA = digitalRead(ButtonPinA); if (buttonStateA == HIGH && brightness! = 255) { brightness++; } buttonStateB = digitalRead(ButtonPinB); if (buttonStateB == HIGH && brightness! = 0) { brightness--; } analogWrite(LedPinA, brightness); / / A few Guan Yuan (ii)? analogWrite(LedPinB, 255 - brightness); // B Yuan (ii) a few Bang? delay(25); }
https://altlab.org/d/s/tools/hardware/sensors/




Keyes KY-017 Arduino Mercury Tilt Switch: Tutorial




// Henry's Bench //KY-017 Mercury Switch Tutorial; int tiltSwitch = 3; // Tilt Switch Input int tiltVal; // variable to store tilt input boolean bIsTilted ;// define numeric variables val void setup () {   Serial.begin(9600);   pinMode (tiltSwitch, INPUT) ;// define the mercury tilt switch sensor output interface } void loop () {   tiltVal = digitalRead (tiltSwitch) ;// read the switch value   if (tiltVal == HIGH) // Means we've tilted   {     if (!bIsTilted){       bIsTilted = true;       Serial.println("** - TILTED - **");     }    }   else   {     if (bIsTilted){       bIsTilted = false;       Serial.println("not tilted");     }       } }
http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/keyes-ky-017-arduino-mercury-tilt-switch-tutorial/


KY-017 Neigungsschalter Modul

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde.

Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY-029 verwendet werden.


int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable
   
void setup ()
{
  pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
  pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
}
   
void loop ()
{
  val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen
   
  if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
  {
    digitalWrite (Led, LOW);
  }
  else
  {
    digitalWrite (Led, HIGH);
  }
http://www.linkerkit.de/index.php?title=KY-017_Neigungsschalter_Modul

Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf





*********************************************************
3.16 KY-018 - Analoger Fotowiderstand  GL5528  Dm=5mm
Arduino KY-018
FotowiderstandsModul - Photoresistor


-      = GND
Vcc = +5,0V
S     = Signal  = ARDUINO ADC pin-2
Print 18,5x17mm


Arduino KY-018 Photo resistor module

BlackBoard Circuit Designer Schaltplan


Das Modul enthält einen einfachen kleinen Fotowiderstand (Dm=5mm)  (LDR = Light Dependent Resistor).
Je mehr Licht auf die Oberläche des Fotowiderstandes fällt, desto kleiner wird der elektrische Widerstand.
Bei Dunkelheit liegt der Widerstand bei ca. 20k und geht dann bei Lichteinfall auf einige ca. 300 Ohm zurück.
Der Widerstand kann entweder direkt gemessen werden oder es wird zusammen mit dem Festwiderstand ein Spannungsteiler aufgebaut.




LDR (Fotowiderstand)
Widerstand dunkel >20MOhm, hell <80Ohm.
Der LDR05 ist an den beiden äußeren Pins angeschlossen.
Zusätzlich ist zwischen dem mittleren Anschluss und dem „S“-Pin noch ein 10k Ohm Widerstand auf der Platine enthalten, damit man eine Messbrücke aufbauen kann.

Inhalt
1. Übersicht
2 Technische Daten
3 Schema
4 Beispielcode

Überblick
Fotowiderstände, auch bekannt als lichtempfindliche Widerstände (LDR), sind lichtempfindliche Geräte, die am häufigsten verwendet werden, um die Anwesenheit oder Abwesenheit von Licht anzuzeigen oder die Lichtintensität zu messen.
Im Dunkeln ist ihr Widerstand sehr hoch, manchmal bis zu 1M Ohm, aber wenn der LDR-Sensor Licht ausgesetzt wird, sinkt der Widerstand je nach Lichtintensität sogar bis auf wenige Ohm drastisch.
LDRs haben eine Empfindlichkeit, die mit der Wellenlänge des angewandten Lichts variiert und nichtlineare Vorrichtungen sind.
Sie werden in vielen Anwendungen verwendet, werden aber manchmal von anderen Geräten wie Photodioden und Phototransistoren veraltet.
Einige Länder haben LDRs aus Blei oder Cadmium aus Gründen des Umweltschutzes verboten.

Weit verbreitet in Kameras, Solar-Garten Lichter, Rasen, Detektoren, Uhr, Musik, Tassen, Geschenk-Boxen, miniNight Licht, leichte Stimme Schalter, Lichter automatisch schalten Spielzeug und eine Vielzahl von Lichtsteuerung, Lichtsteuerung Beleuchtung, Lampen und andere leichte automatische Öffnung

Technische Daten

Nach den spektralen Eigenschaften des Photoresistors hat drei Photowiderstand: Ultraviolett lichtempfindlichen Widerstand, Infrarot-lichtempfindliche Widerstände, sichtbare lichtempfindliche Widerstand;
Die wichtigsten Parameter sind wie folgt:
Dunkelstrom, Dunkelwiderstand: lichtempfindlicher Widerstand bei einer bestimmten angelegten Spannung, wenn das Licht nicht bestrahlt wird, wenn der fließende Strom als Dunkelstrom bezeichnet wird. Angelegtes Spannungs- und Dunkelstromverhältnis als Dunkelwiderstand;
Empfindlichkeit:
Die Empfindlichkeit wird durch lichtempfindlichen Widerstand bestrahlt, der Widerstandswert (dunkler Widerstand) bei Bestrahlung mit Licht Widerstandswert (Lichtwiderstand) die relative Änderung der Werte.
Volt-Ampere-Kennlinie. Spannungskennlinien werden verwendet, um den Widerstand der angelegten Spannung und die photoempfindliche Photostrombeziehung zu beschreiben.
Auf den lichtempfindlichen Vorrichtungen nimmt der Lichtstrom mit angelegter Spannung zu.
Temperaturkoeffizient. Photoelektrischer Effekt Photowiderstand, der durch Temperatur beeinflußt wird, an einem niedrigen Temperaturabschnitt Fotowiderstand photoelektrisch Empfindliche hohe Empfindlichkeit bei hohen Temperaturen ist niedrig.
Nennleistung. Lichtempfindliche Widerstand Nennleistung ist für bestimmte Leitungen in der Energie verbraucht, wenn der Temperaturanstieg hoch ist, ist seine Leistungsaufnahme reduziert.

ARDUINO               MODUL KY-018
pin-GND     zu        pin minus  GND)
pin+5V       zu        + 5V (Pin-mitte)
pin-A5        zu         pin-S       (Signal)



Beispielcode für ARDUINO UNO
Sketch KY-018

//KY018 Photo resistor module
 
int sensorPin = A5; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
void setup() {
  pinMode(ledPin, OUTPUT);
  Serial.begin(9600);
}
void loop() {
  sensorValue = analogRead(sensorPin);
  digitalWrite(ledPin, HIGH);
  delay(sensorValue);
  digitalWrite(ledPin, LOW);
  delay(sensorValue);
  Serial.println(sensorValue, DEC);
}
https://tkkrlab.nl/wiki/Arduino_KY-018_Photo_resistor_module
http://electronicastore.net/tutorial-usar-el-sensor-ky-018-photoresistor-y-arduino/


Der Photowiderstand liest gerade den analogen Spannungswert des Moduls und druckt den Wert.
Wenn es Licht gibt, ist die Ausgangsspannung hoch, ohne Licht gibt es eine niedrige Spannung. Siehe Werte für den seriellen Monitor
Source example code:
https://s3.amazonaws.com/linksprite/Arduino_kits/advanced_sensors_kit/KY018+code.pdf
See also example on
http://nakkaya.com/2009/10/29/connecting-a-photoresistor-to-an-arduino/




Arduino UNO Tutorial 8 - NightLight

Hier ist die Schaltung auf einem Steckbrett (BreadBoard).
5V und 0V sind dem Arduino entnommen.
Der Eingang geht an pin-A0

Arduino BreadBoard
Unten ist die Arduino-Sketch. In diesem Sketch schalten wir die eingebaute LED einfach ein, wenn der ADC-Wert unter einen bestimmten Wert fällt.
Um ein Nachtlicht zu machen, kann eine hellere LED (mit Begrenzungswiderstand ~ 220 Ohm) an den pin-13 Ausgang angeschlossen werden.

In dem Code werden Sie feststellen, dass es einige serielle Ausgabe-Anweisungen, die kommentiert werden.
Wenn Sie dies kommentieren, sehen Sie auf dem seriellen Monitor den aktuellen Wert der Spannung, die vom Arduino ADC Eingang gelesen wird.

Dieser Wert liegt zwischen 0 und 1024.
Bedecke den LDR mit deiner Hand und leuchte ein Licht darauf, um den Effekt zu sehen.


Ändern Sie den Wert in dem Code, in dem die LED eingeschaltet ist, auf einen geeigneten Wert.



/*
** Nightlight LDR test program
** Created 06 Feb 2010
**
** This example code is in the public domain.
** www.hobbytronics.co.uk
*/

int sensorPin = A0;            // select the input pin for the ldr
unsigned int sensorValue = 0;  // variable to store the value coming from the ldr

void setup()
{
  pinMode(13, OUTPUT);
  //Start Serial port
  Serial.begin(9600);        // start serial for output - for testing
}

void loop()
{
  // read the value from the ldr:
  sensorValue = analogRead(sensorPin);     
  if(sensorValue<400) digitalWrite(13, HIGH);   // set the LED on
  else digitalWrite(13, LOW);   // set the LED on
  
  // For DEBUGGING - Print out our data, uncomment the lines below
  //Serial.print(sensorValue, DEC);     // print the value (0 to 1024)
  //Serial.println("");                   // print carriage return  
  //delay(500);  
}


http://www.hobbytronics.co.uk/arduino-tutorial8-nightlight


https://codebender.cc/sketch:68987#KY-018%20Photo%20resistor%20module.ino

http://playground.arduino.cc/Learning/PhotoResistor
http://www.instructables.com/id/How-to-use-a-photoresistor-or-photocell-Arduino-Tu/
https://learn.adafruit.com/photocells/using-a-photocell
http://bildr.org/2012/11/photoresistor-arduino/
http://www.resistorguide.com/photoresistor/




Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf



KY-018        Photoresistor  LDR

Photoresistor

In diesem Post geht es darum, wie man einen Photoresistor mit dem Arduino verwenden. Dadurch kann man die Helligkeit mit dem Arduino messen.

Dieser Post ist Teil der Artikelserie über das Ultimate Arduino Sensor Kit mit 37 Sensoren. Das Kit, inklusive Photoresistor, gibt es hier auf Amazon.  Den Photoresistor einzeln findet ihr hier auf Amazon.  


Funktionsweise

Um den Photoresistor mit dem Arduino zu verwenden, muss man nur Pin S mit einem analog Eingang verbinden, - mit dem Ground und den mittleren Pin mit +5V. 

Ein Photoresistor ist relativ leicht mit dem Arduino auszulesen. Dabei ist wird Strom durch den Photoresistor geleitet. Ist es dunkel, so ist der Widerstand sehr groß, und es gibt nur eine kleine Spannung. Sobald es hell ist wird der Widerstand sehr klein, und man erhält die vollen 5V Spannung.


Der Sketch

Im Sketch muss man eigentlich nur den jeweiligen analog Eingang auslesen, und mit der Spannung bei normalem Licht (~100) vergleichen. Dadurch weiß man, wie hell oder dunkel es ist.


void setup() {
Serial.begin(9600);

}

void loop() {
if(analogRead(A5) >= 100)
{
Serial.println("Hell!");
}
else {
Serial.println("Dunkel!");
}
}

Photoresistor.ino hosted with ❤ by GitHub

Anwendungsgebiete

Für einen Photoresistor gibt es in Kombination mit dem Arduino sehr viele Verwendungsmöglichkeiten. So ist beispielsweise das Dimmen von LEDs in Abhängigkeit vom Umgebungslicht eine gute Möglichkeit Strom zu sparen, was insbesondere bei Batterie betriebenen Projekten wichtig ist.

Ein weiteres cooles Projekt mit einem Photoresistor ist ein Theremin. Dabei wird abhängig von der Helligkeit die Tonhöhe geändert:






*********************************************************
3.17   KY-019 - Relais
Arduino KY-019
5V Relais-Modul - Relay
LED am Print
Fa. SONGLE SRD-05Vdc-SL-C


-      = GND
Vcc = +5,0V
S     = Signal  = ARDUINO pin-10
Print 33x26mm


Mit einem Relais kann mittels einer kleinen Spannung eine große Last gesteuert werden.
Der Lastkreis ist dabei galvanisch vom Steuerkreis getrennt. Aufgrund der Mechanik ist der Schaltvorgang durch ein hörbares Geräusch wahrnehmbar.
Die Schaltfrequenz liegt je nach Typ bei etwa 10 Hz und es sind nur etwa 250.000 Schaltzyklen zuverlässig möglich.
Das Relais weist bauartbedingt mehrere Nachteile auf.
So neigt es zum Prellen und bei höheren Lasten kommt es zu Funkenbildung an den internen Lastkontakten.
Aus diesem Grund sollte auf der Lastseite immer ein sogenannter Snubber aus Widerstand und Kondensator passend zur Belastung aufgebaut werden.
Wenn der Snubber fehlt, kann es auch zu Abstürzen des steuernden Mikrocontrollers kommen.

BlackBoard Circuit Designer Schaltplan


Auf der Schaltseite wird eine Freilaufdiode benötigt, um die selbstinduzierte Spannung beim Abfallen des Relais kurzzuschließen, da die Spannungsspitze ansonsten die ansteuernde Elektronik beschädigen kann.

Auf dem Modul ist sowohl die Freilaufdiode verbaut als auch ein Transistor zur Ansteuerung, da der Steuerstrom für das Relais zu hoch für die meisten Mikrocontroller ist.
Beim genutzten Relais handelt es sich um einen einfachen Umschalter 1xUM, der bei 5 V (90 mA) schaltet und eine Last von bis zu 10 A bei 250 V Wechselspannung verkraftet.
Die LED leuchtet, wenn das Relais angesteuert wird.



Arduino KY-019 5V relay module
Relaismodul zum direkten Anschluss an den Arduino, benötigt 5V Stromversorgung.
Die Steuerleitung ist mit „S“ gekennzeichnet.
Das Relais besitzt einen Schaltkontakt, die Belastbarkeit für ohmsche Lasten ist bei
Wechselspannung max. Spannung von max. 250Vac ein Strom bis zu 10 Amp.
Gleichspannung    max. Spannung von max.   30Vdc ein Strom bis zu 10 Amp. 
geschaltet werden.


Inhaltsverzeichnis - 5V-Relaismodul
1 Verwendung
2 Technische Daten
3 Schema
4 Modulprüfung
5 Beispielcode

Benutzen
Das Relais-Modul kann an 240Vac oder 28Vdc in eine Vielzahl von anderen elektrischen Teilen angeschlossen werden.
Das Relais kann in Anti-Diebstahl-Alarm, Spielzeug, etc. verwendet werden.
Relais ist ein elektrisch gesteuertes Gerät.
Es hat ein Steuersystem (auch als Eingangsschaltung bekannt) und das Steuersystem (auch bekannt als die Ausgangsschaltung).

Häufig in der Automatisierung Steuerkreis verwendet, ist es tatsächlich ein kleiner Strom zur Steuerung einer großen aktuellen Betrieb "automatischen Schalter."
Daher stellt die Schaltung automatisch das Spiel, Sicherheit Schutz, Übertragung Umwandlung Schaltung und so weiter.
Besonders geeignet für Single-Chip-Steuerung starke elektrische Geräte.
In der Steuerung und Verwendung ist auch sehr bequem, geben Sie geben entsprechende Ausgangsrelais verschiedenen Ebenen, können Sie durch die Steuerung der Relais-Steuerung andere Geräte, zusätzlich in der Multi-Kanal-Relais PCB-Layout auf die Verwendung von zwei Leitungen Layout, Benutzer-Lead-Verbindungen.
Während in der Schaltung einer DC-Diode hinzugefügt stark verbesserte Relais

Modul zum Einschalten der Stromfähigkeit, um zu verhindern, dass der Transistor gebrannt wird.
Zusätzlich fügten wir ein Relais dieser Energienanzeige hinzu Leuchten (ausgenommen Relais ganz), die Anzeige ist Rot.
In hellsten Relais fügt auch eine Statusanzeige.

Technische Daten
Die wichtigsten Zweck Relay ist eine Funktion der automatischen Trennschaltelemente, sind weit verbreitet in der Fernbedienung, Telemetrie, Kommunikation, automatische Steuerung, Mechatronik und Leistungselektronik verwendet, ist eines der wichtigsten Steuerelemente.
Kocht auf den folgenden Effekt:
Erweitern Sie den Regelbereich:
z.B. erhält das Multikontaktrelais-Steuersignal einen bestimmten Wert, können Sie nicht auf die Kontaktgruppe Unterschiedliche Formen und für Zugang, brechen, angeschlossene Mehrkanalschaltungen drücken.
Zoom:
zum Beispiel, empfindliche Relais, Relais, etc., mit einer sehr kleinen Menge an Kontrolle, können Sie eine große Die Macht der Schaltung.
Integrierte Signal:
zum Beispiel, wenn eine Vielzahl von Steuersignalen in der Form vorgeschriebenen Eingang Multi-Wickel-Relais, durch Vergleichsmechanismen zusammen, um die gewünschte Kontrolle zu erreichen.
Automatische, Fernbedienung und Überwachung: zum Beispiel, das automatische Gerät Relais zusammen mit anderen Geräten, kann der Programmsteuerung Draht Linie, um einen automatischen Betrieb zu erreichen
Hinweis
Nennspannung: bezieht sich auf normale Arbeitszeit Relais Spule Spannung erforderlich, Der Steuerkreis ist eine Steuerspannung.
Entsprechend dem Relaismodell kann ac Druck sein, es kann eine Gleichspannung sein.
DC-Widerstand: bezieht sich auf die Relaisspule DC-Widerstand, gemessen durch das Multimeter.
Pick-up-Strom: bezieht sich auf die Relais ziehen Aktion kann einen minimalen Strom zu produzieren.
Bei normaler Verwendung wird der Strom etwas größer als der Zugstrom sein, so daß das Relais stabil betrieben werden kann.
Die Arbeit der Spule Spannung angewendet wird, in der Regel nicht mehr als 1,5 mal die Nenn-Arbeitsspannung, sonst wird es einen größeren Strom zu der Spule verbrannt haben.
Release-Strom: bezieht sich auf das Relais generiert die maximale aktuelle Freigabe Aktion.
Wenn der Relaisstatusstrom in einem bestimmten Ausmaß verringert wird, kehrt das Relais zur Freigabe des unversorgten Zustands zurück.
Dann ist der Strom viel kleiner als der Zugstrom.
Kontaktschalter Spannung und Strom: ist das Relais, um die angelegte Spannung und Strom zu ermöglichen.
Sie bestimmt das Relais, um Spannung und gegenwärtige Größe zu kontrollieren, Gebrauch kann diesen Wert nicht überschreiten, es ist sehr einfach, die Relaiskontakte zu beschädigen.

ARDUINO UNO              MODUL KY-019
pin-GND           zu           Pin -
pin+5V             zu           Pin +
Digital pin-10     zu         Pin-S


Modulprüfung
Pin Beschreibung unten Beschreibung: COM zu VCC, NEIN dann müssen wir die LED Anode steuern, die wie wenn das Relais einschält, LED-Lichter leuchten;
Um das Aussehen dieses Tests zu vervollständigen, muss darauf vorbereitet sein, was sie speziell

Arduino Steuergerät
USB Datenkabel
1 Relaismodul
LED-Anzeige
Widerstands 330R



Beispielcode für ARDUINO UNO
Sketch KY-019


//KY019 5V relay module
int relay = 10;               // relay turns trigger signal - active high;

void
setup () { pinMode (relay, OUTPUT); // Define port attribute is output; } void loop () { digitalWrite (relay, HIGH); // relay conduction; delay (1000); digitalWrite (relay, LOW); // relay switch is turned off; delay (1000); }

ODER

// Relais Steuerpin an Arduino 8 const int relaisPin = 8;   void setup() { pinMode(relaisPin, OUTPUT); }   void loop() { digitalWrite(relaisPin, HIGH); delay(500); digitalWrite(relaisPin, LOW); delay(1000); }
ODER

const int relaisPin = 13;

void setup() {
  pinMode(relaisPin, OUTPUT); // Den PWM PIN "relaisPin" als Ausgangssignal setzen.
}
void loop() {
  digitalWrite(relaisPin, HIGH); //Relais an
  delay(500);  //500ms warten
  digitalWrite(relaisPin, LOW);  //Relais aus
  delay(1000);// 1000ms warten
}


Programm Beschreibung: 
Das Programm Hinweise in der Leitung und Trennung bezieht sich auf die Art und Weise,
dass wir wollen, dass wir mit der NO-Seite,
Wenn S-Relais schaltet in High und schlagen die NO-Seite, wird der Schalter eingeschaltet,
an die LED angeschlossen sein wird Leuchtet, ansonsten schalten Sie die NC-Seite,
keine Richtung trennen, LED-Licht erlischt; Sie werden sehen,
die Testergebnisse LED-Leuchten blinkt Intervall 1s;

https://tkkrlab.nl/wiki/Arduino_KY-019_5V_relay_module


Codebeispiel Arduino

MODUL                ARDUINO
Sensor -           =  pin-GND
Sensor +          =  pin+5V
Signal  S          =  pin-10

Das Programm bildet einen Blinker nach

Es schaltet das Relais in vorher definierter Zeit (delayTime) zwischen den beiden Zuständen (bzw. Ausgangsterminals) um.

int relay = 10;  // Hier wird der Pin deklariert, an dem das Relay angeschlossen ist
delayTime = 1   // Wert in Sekunden, wie lange zwischen den Umschaltungen gewartet werden soll
 
void setup ()
{
  pinMode (relay, OUTPUT); // Der Pin wird als Ausgang deklariert
}
 
      // Das Programm bildet einen Blinker nach - es schaltet das Relais in vorher definierter
      // Zeit (delayTime) zwischen den beiden Zuständen (bzw. Ausgangsterminals) um.

void
loop ()
{
  digitalWrite (relay, HIGH);  // "NO" ist nun kurzgeschlossen;
  delay (delayTime * 1000);
  digitalWrite (relay, LOW);   // "NC" ist nun kurzgeschlossen;
  delay (delayTime * 1000);
}


KY-019_Relais.zip

http://www.linkerkit.de/index.php?title=KY-019_5V_Relais_Modul

Arduino: Relais ansteuernmit ULN2003

http://playground.arduino.cc/Deutsch/Relais
http://funduino.de/nr-15-relaisshield
http://stefan-draeger-software.de/blog/arduino-lektion-13-2-fach-relaisplatine-ansteuern/



Treiberschaltung: Schalten/Steuern eines Relais mit TTL-Signal (5V)


Relais 351-803 von RS-Components
http://www.elektronik-kompendium.de/sites/slt/1201131.htm



 /* Simple relay controlling firmware
  * Mike Schilli, 2013 (m@perlmeister.com)
  */

 void setup() {
   Serial.begin(9600);
   pinMode(11, OUTPUT);
   digitalWrite( 11, HIGH );
   pinMode(13, OUTPUT);
   digitalWrite( 13, LOW );
 }

 void loop() {
   while( Serial.available() > 0 ) {
     int val = Serial.read();
     Serial.print( val );
     if( val == '1' ) {
       digitalWrite( 11, LOW );
       digitalWrite( 13, HIGH );
     } else {
       digitalWrite( 11, HIGH );
       digitalWrite( 13, LOW );
     }
   }
 }

http://www.linux-magazin.de/Ausgaben/2014/01/Perl-Snapshot

Arduino 4-fach Relais Shield



Der Arduino 4 Relais-Schild bietet eine Lösung zum Schalten bzw. Ansteuern von höheren Lasten, die aufgrund der Strom und Spannungsgrenzen der digitalen IO´s vom Arduino direkt nicht möglich sind.
Der Shield verfügt über vier Relais, jedes Relais bietet einen 2-poligen Wechsler NO (normally open) und NC (normally closed);
Vier LEDs zeigen den Ein / Aus-Zustand jedes Relais.

Der Shield benötigt keine externe Versorgungsspannung. Er wird durch die Basispin´s des Arduinos versorgt.
Relay 1 = Arduino pin 4
Relay 2 = Arduino pin 7
Relay 3 = Arduino pin 8
Relay 4 = Arduino pin 12

http://physicalcomputing.at/Arduino-4-Relais-Shield


Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf




KY-019 Relais


Relais

In diesem Post geht es darum, wie man ein Relais mit dem Arduino verwendet. Dadurch kann man über den Arduino auch große Ströme und Spannungen, beispielsweise 230V Netzspannung, steuern.


Dieser Post ist Teil der Artikelserie über das Ultimate Arduino Sensor Kit mit 37 Sensoren. Das Kit, inklusive Relais, gibt es hier auf Amazon.  Ein Relais einzeln findet ihr hier auf Amazon.

Funktionsweise

Im Relais gibt es zwei Stromkreise: einen Steuerstromkreis, und den Stromkreis für das Endgerät. Sobald man Strom auf den Steuerstromkreis gibt, fließt dieser durch eine Spule, und es bildet sich ein Elektromagnet. Dadurch wird ein Stück Metall angezogen, und der Stromkreis für das Endgerät schließt sich.



Relais Animation“ von Stefan Riepl (Quark48) - selbst gezeichnet mit Paint - Bild vom Relais war gemeinfrei aus der Wikipedia.. Lizenziert unter CC BY-SA 2.0 de über Wikimedia Commons.


Verbindung

Die Verbindung mit dem Arduino läuft über drei Kabel. - muss mit dem Ground verbunden werden, + mit den +5V des  Arduino und S ist der Signalpin. Dieser muss mit einem digital Pin des Arduino verbunden werden.

Auch auf der anderen Seite gibt es drei Anschlüsse:
Dabei muss ein Anschluss des zu steuernden Stromkreises immer mit dem mittleren Kontakt verbunden werden. Der mit NO beschriftete Kontakt ist "Normal Open" und der mit NC beschriftete Kontakt "Normal Closed". Je nachdem, wie der Stromkreis normalerweise sein soll, muss man also den zweiten Kontakt wählen.

Da ein Relais im Prinzip nichts weiter als ein über den Arduino gesteuerter Schalter ist, kann er an einer beliebigen Stelle des Stromkreises eingebaut werden. 

Dabei muss ein Kabel durchgeschnitten werden, und dann ein Ende in den mittleren Kontakt, und ein Ende an einen der beiden äußeren Kontakte angeschlossen werden. Natürlich ist es möglich über das geschickte Wählen der Stelle im Stromkreis das Zerschneiden eines Kabels zu verhindern.

Um die Kontakte mit dem Relais zu verbinden, muss man die Schrauben rausdrehen, den Draht hineinschieben, und sie wieder zu drehen. 

Warnung: Während des Betriebs darf man das Relais nie anfassen, da es offenen Kontaktstellen gibt, wodurch man bei Berührung einen Stromschlag bekommen kann! 

Die unterstützte Spannung und Stromstärke steht jeweils auf dem Relais drauf. Zum ersten Testen empfehle ich das Verwenden einer kleinen Spannung/Stromstärke. Eine gute Übung zum Einstieg ist es, eine Taschenlampe über das Relais zu steuern.

Sobald man den Status des Signalpins verändert, klackt das Relais hörbar. Außerdem leuchtet eine rote LED am Relais.

Arduinosketch

Zum Ausprobieren kann man den Standard Blink Sketch verwenden:

blink_ardu.ino hosted with ❤ by GitHub



/*
Blink
Turns on an LED on for one second, then off for one second, repeatedly.

Most Arduinos have an on-board LED you can control. On the Uno and
Leonardo, it is attached to digital pin 13. If you're unsure what
pin the on-board LED is connected to on your Arduino model, check
the documentation at http://arduino.cc

This example code is in the public domain.

modified 8 May 2014
by Scott Fitzgerald
*/


// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin 13 as an output.
pinMode(13, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
digitalWrite(13, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(13, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}







*********************************************************
3.18    KY-020 - Lageabhängiger Schalter mit Kugel
Arduino KY-020
Kippschaltermodul - Ball switch

KY-020 Neigungs-Schalter Modul

Der KY-020 Kugel-Schalter ist der Ersatz für die Quecksilber-Schalter
Arduino KY-017
Quecksilber-Schalter-Modul - Tilt switch





S = Signal = ARDUINO pin-3
Vcc = +5,0V
- = GND
Print 18,5x15mm

BlackBoard Circuit Designer Schaltplan




Bei meinem MODUL ist die Pin-Belegung so.
Pin  - = GND
Pin Vcc = +5,0V

Pin S = Signal = ARDUINO pin-2
Print 18,5x15mm

BlackBoard Circuit Designer Schaltplan




Im Inneren des Bauteils beindet sich eine Kugel, die bei senkrecht Stellung in die Mitte rollt.
Berührt sie die zwei Kontakte, dann ist der Schalter geschlossen.
Der Widerstand wird als Pull-Up verwendet.




Arduino KY-020 Tilt switch module

Lageabhängiger Schalter mit Kugel und eingebautem 10k Ohm Widerstand als Pull-up oder Pull-down zwischen dem mittleren und dem „S“-Anschluss.
Der Schalter ist an den beiden äußeren Pins verbunden.
Belastbarkeit: 12Vdc / 50mA

Tilt-Schalter-Modul und eine digitale Schnittstelle, integrierte LED bauen eine einfache Schaltung zu produzieren Tilt-Warnlampe kommt mit digitalen Schnittstellen der LED, der Neigungsschalter Sensor-Schnittstelle auf digitalen 3 zugreifen, wenn die Neigung offen Aus Sensor erfasst ein Tastensignal, LED leuchtet, sonst aus.



Beispielcode für ARDUINO UNO
Sketch KY-020

int Led = 13 ;     // define LED Interface
int buttonpin = 3; // define the tilt switch sensor interfaces
int val ;          // define numeric variables val
void setup ()
{
  pinMode (Led, OUTPUT) ;         // define LED as output interface
    pinMode (buttonpin, INPUT) ;  //define the output interface tilt switch sensor
}
void loop ()
{
  val = digitalRead (buttonpin) ; // digital interface will be assigned a value of 3 to read val
    if (val == HIGH)              //When the tilt sensor detects a signal when the switch, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}

https://tkkrlab.nl/wiki/Arduino_KY-020_Tilt_switch_module
http://www.instructables.com/id/Arduino-Tilt-Switch-Switching-on-a-RELAY-With-the-/


http://www.arduino.cc/en/Tutorial/Button

*/
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
// variables wil
l change:
int buttonState = 0; // variable for reading the pushbutton status
void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}
void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
}


http://misclab.umeoce.maine.edu/boss/Arduino/bensguides/KeyesKY-020Tilt_Sensor_Instructions.pdf


KY020: Tilt Switch Module

/*
Button
Turns on and off a light emitting diode(LED) connected to digital
pin 13, when pressing a pushbutton attached to pin 2.

The circuit:
* LED attached from pin 13 to ground
* pushbutton attached to pin 2 from +5V
* 10K resistor attached to pin 2 from ground
* Note: on most Arduinos there is already an LED on the board
attached to pin 13.

created 2005
by DojoDave
modified 28 Oct 2010
by Tom Igoe

This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/Button
*/


// constants won't change. They're used here to
// set pin numbers:

const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin

// variables will change:
int buttonState = 0; // variable for reading the pushbutton status


void setup() {
// initialize the LED pin as an output:
pinMode(ledPin, OUTPUT);
// initialize the pushbutton pin as an input:
pinMode(buttonPin, INPUT);
}


void loop(){
// read the state of the pushbutton value:
buttonState = digitalRead(buttonPin);
// check if the pushbutton is pressed.
// if it is, the buttonState is HIGH:
if (buttonState == HIGH) {
// turn LED on:
digitalWrite(ledPin, HIGH);
}
else {
// turn LED off:
digitalWrite(ledPin, LOW);
}
}


http://learn.linksprite.com/arduino/sensors-kit-for-arduino/ky020-tilt-switch-module/


Beispiele in Deutsch
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (SKA-36)_1a.zip
715_d_ARDUINO-x_37-in-1 Sensor kit for ARDUINO - alle 37 Beispiele (227 Seiten)_1a.pdf




DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE








Comments