http://sites.schaltungen.at/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
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 KY011int redpin = 11; // select the pin for the red LEDint greenpin = 10; // select the pin for the green LEDint 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
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 pinbyte 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 conversiondouble 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 conversiondouble 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_pointdouble 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 2void 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
// 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)
|
|
// 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) ;
|
|
// 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 temp = (a * celsius) / (b + celsius) + log(humidity*0.01);
|
|
double Td = (b * temp) / (a - temp);
|
|
Serial.println("DHT11 TEST PROGRAM ");
|
|
Serial.print("LIBRARY VERSION: ");
|
|
Serial.println(DHT11LIB_VERSION);
|
|
int chk = DHT11.read(DHT11PIN);
|
|
Serial.print("Read sensor: ");
|
|
case DHTLIB_ERROR_CHECKSUM:
|
|
Serial.println("Checksum error");
|
|
case DHTLIB_ERROR_TIMEOUT:
|
|
Serial.println("Time out error");
|
|
Serial.println("Unknown error");
|
|
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));
|
|
//
*********************************************************
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 moduleint redpin = 11; // select the pin for the red LEDint bluepin = 10; // select the pin for the blue LEDint greenpin = 9 ;// select the pin for the green LEDint 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 groundint greenpin = 9; // select the pin for the green LEDint redpin = 10; // select the pin for the red LEDint 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 moduleint Led = 13 ;// define LED Interfaceint buttonpin = 3; // define the mercury tilt switch sensor interfaceint val ;// define numeric variables valvoid 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 Inputint tiltVal; // variable to store tilt inputboolean bIsTilted ;// define numeric variables valvoid 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 potentiometerint ledPin = 13; // select the pin for the LEDint sensorValue = 0; // variable to store the value coming from the sensorvoid 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 ldrunsigned int sensorValue = 0; // variable to store the value coming from the ldrvoid 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
Photoresistor
In diesem Post geht es darum, wie man einen Photoresistor mit dem Arduino verwenden. Dadurch kann man die Helligkeit mit dem Arduino messen.
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.
if(analogRead(A5) >= 100)
|
|
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 moduleint 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 8const 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 ([email protected]) */ 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.
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
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.
|
|
// the setup function runs once when you press reset or power the board
|
|
// initialize digital pin 13 as an output.
|
|
// the loop function runs over and over again forever
|
|
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 Interfaceint buttonpin = 3; // define the tilt switch sensor interfacesint val ; // define numeric variables valvoid 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:[email protected]
ENDE
|