KY-031..040


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

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
 

KY = Keyes


715_d_ARDUINO-x_ALLNET Arduino 37-in-1 Sensor Kit +++ Beschreibung (12 Seiten)_1a.pdf
704_d_fritz-x_SENSOREN AM ARDUINO 2  37-in-1 (Seite 59..97)_1a.pdf

37-in-1-arduino-sensor-kit




3.28   KY-031 - Schock-Sensor
Arduino KY-031
Klopf-Sensor Modul - Tap module
KY-031 Knock-Sensor module
KY-031 Klopfsensor-Modul
KY-031 Erschütterungs-Modul


So ist mein Modul Belegt

BlackBoard Circuit Designer Schaltplan
KY-031 bis KY-040 Schaltungen_1a.bbs

Die lange Feder im Inneren des durchsichtigen Gehäuses schlägt bei großen Beschleunigungs-oder Verzögerungskräften (g-Kraft) gegen den Kontakt und schließt dann für einen kurzen Moment den Stromkreis.
Aufgrund der Trägheit und einer damit einhergehenden Unempindlichkeit gegenüber geringen Kräften eignet sich der Sensor gut, um einen starken Aufprall / Stoß zu erkennen.



Arduino KY-031 Knock Sensor module

Erschütterungskontakt, der Kontaktschalter ist an den beiden äußeren Pins angeschlossen.
KEYES ARDUINO Klopfsensormodul

pin-13 Klopfsensor-Modul und eine digitale Schnittstelle, integrierte LED bauen eine einfache Schaltung, um Percussion Blinkgeber zu produzieren.
pin-13  kommt mit digitaler LED, klopft Sensor angeschlossenes digitales 3 Schnittstelle, wenn Schlagzeug-Sensor-Abfragung Maß
Für perkussive Signale, LED-Blitzlicht.


Beispielcode für ARDUINO UNO
Sketch KY-031

// Use the LED comes with digital pin 13, and connect the shock sensor output to digital pin 3, when the shock sensor senses vibration, LED will blink.
int Led = 13 ; // define LED Interface
int Shock = 3  // define the percussion Sensor Interface
int val ;      // define numeric variables val
 
void setup ()
{
  pinMode (Led, OUTPUT) ;  // define LED as output interface
  pinMode (Shock, INPUT) ; // define knock sensor output interface
}
void loop ()
{
  val = digitalRead (Shock) ; // read digital interface is assigned a value of 3 val
  if (val == HIGH)            // When the percussion when the sensor detects a signal, LED flashes
  {
    digitalWrite (Led, LOW);
  }
  else
  {
    digitalWrite (Led, HIGH);
  }
}

https://tkkrlab.nl/wiki/Arduino_KY-031_Knock_Sensor_module






//Henry's Bench
//KY-031 Knock Sensor Tutorial
int knockPin = 10; // Use Pin 10 as our Input
int knockVal = HIGH; // This is where we record our shock measurement
boolean bAlarm = false;

unsigned long lastKnockTime; // Record the time that we measured a shock


int knockAlarmTime = 500; // Number of milli seconds to keep the knock alarm high


void setup ()
{
  Serial.begin(9600);  
  pinMode (knockPin, INPUT) ; // input from the KY-031
}
void loop ()
{
  knockVal = digitalRead (knockPin) ; // read KY-031 Value
  
  if (knockVal == LOW) // If we see a knock
  {
  
    lastKnockTime = millis(); // record the time of the shock
    // The following is so you don't scroll on the output screen
    if (!bAlarm){
      Serial.println("KNOCK, KNOCK");
      bAlarm = true;
    }
  }
  else
  {
    if( (millis()-lastKnockTime) > knockAlarmTime  &&  bAlarm){
      Serial.println("no knocks");
      bAlarm = false;
    }
  }
}


http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/keyes-ky-031-arduino-knock-impact-sensor-manual-and-tutorial/
http://www.instructables.com/id/Arduino-Tutorials-part-3-17-Tutorial-Pack/step15/Arduino-And-Shock-Knock-Sensor-KY-031/
https://sites.google.com/site/summerfuelrobots/arduino-sensor-tutorials/knock-tap-sensor-ky-031
https://wiki.makerspace.se/KY-031


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






*********************************************************

Hindernis-Detektor Modul KY-032 Dioden schauen nach vorne um ein Hinderniss zu erkennen
Tracking-Sensor Modul KY-033     Dioden schauen nach unten um einer schwarzen Linie zu folgen



Arduino KY-032 Hindernisvermeidungssensormodul - Tracking
                              *** wurde nicht geliefert ***
KY-032 Obstacle avoidance sensor module
KY-032 Hindernisvermeidungs-Sensor Modul
KY-032 IR-Reflex-Lichtschranke

                                                           
                                                       Vcc +5V

                                                            OUT
                                                                GND


http://circuitdigest.com/electronic-circuits/ir-sensor-circuit-diagram





Arduino KY-032 Obstacle avoidance sensor module



IR-Reflexlichtschranke-Sensor TCRT5000   
http://blog.huntgang.com/2014/06/17/arduino-tcrt5000-build-ir-sensor/

Trimmer 10k
Op-Amp  LM393
LM393 - Low Offset Voltage Dual Comparators
LM193 / LM293 / LM393 / LM2903 - Low Power Low Offset Voltage Dual

IR-Reflexlichtschranke - Linienverfolger
z.B. zur Hinderniserkennung oder dem Verfolgen einer Linie mit einem Modell auf dem Boden.
Wird vor den Sende- / Empfangsdioden ein Hindernis platziert, schaltet der mit „Out“ beschriftete Ausgang nach Masse (low active) durch.
Die Empfindlichkeit der Lichtschranke kann mit dem Poti eingestellt werden.
Die Schaltentfernung kann bis ca. 1cm betragen.


Ermöglicht das Erfassen von festen Objekten innerhalb eines festen Bereichs (einstellbar mit eingebautem Potentiometer).
Ideal für Roboteranwendungen.
Abhängig von der Position der Potentiometer und der reflektierenden Oberfläche ist der Erfassungsbereich zwischen ca. 5 und 45cm.

Versorgungsspannung: 3..6V
Digitalausgang:            0 = Objekt erkannt, 1 = kein Objekt erkannt
Erfassungsbereich:      5 bis 45cm (ungefähr - sehen Sie bitte Anmerkung oben)


Infrarot-Hindernis-Vermeidungssensor ist für die Konstruktion eines Rädern Roboter Hindernis Vermeidung Sensor Abstand einstellbar.
Dieser Umgebungslichtsensor Anpassungsfähig, hochpräzise, ​​mit einem Paar Infrarotsender und -empfänger senden Senderröhren eine bestimmte Frequenz des Infrarots aus, wenn die Richtung eines Hindernisses (Reflektor), der Infrarotempfänger-Schlauchempfänger reflektiert wird zurück reflektiert, wenn die Anzeige
Leuchtet,
Durch die Schaltung, die Signalausgangs-Schnittstelle Ausgang digitales Signal, das mit Hilfe von Potentiometer-Knopf, um den Abstand,
der effektive Abstand von 2 .. 40cm,
Betriebsspannung  von 3,3V..5,0V,

Relativ große Schwankungen in der Versorgungsspannung der Situation

Technische Daten
    
Arbeitsspannung:         DC 3,3V..5,0Vdc
    
Arbeitsstrom:               ≥ 20mA
    
Betriebstemperatur:      -10 ℃ - +50 ℃
    
Erkennungsabstand:     2..40cm
    
IO-Schnittstelle:           4-Leiter-Schnittstellen (- / + / S / EN)
    
Ausgangssignal:           TTL-Pegel (Low-Pegel gibt es ein Hindernis, kein Hindernis hoch)
    
Einstellung:                  Potentiometer
    
Wirksamer Winkel:       35 °
    
Größe:                        28 × 23mm
    
Gewicht Größe:           9g

Hier verwenden wir das Reflex Modul und eine digitale Schnittstelle, eingebaute pin-13 LED bauen eine einfache Schaltung,
die Vermeidung Warnlampe, das Hindernis Vermeidung Sensor Access Digital 3-Schnittstelle, wenn Hindernisse Vermeidung Sensor ein Signal, LED-Licht und umgekehrt
aus.



Beispielcode für ARDUINO UNO
Sketch KY-032

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

https://tkkrlab.nl/wiki/Arduino_KY-032_Obstacle_avoidance_sensor_module

http://www.instructables.com/id/OBSTACLE-AVOIDANCE-With-the-KY-032/
http://blog.arduinosensors.nl/2016/11/02/arduino-obstacle-avoidance-ky-032/
http://arduino.stackexchange.com/questions/9082/how-to-increase-the-detection-distance-on-arduino-ky-032-obstacle-avoidance-sens






Anschlussbelegung Arduino:

Sensor Enable  = [N.C. (Steckbrücke gesteckt)]
Sensor Signal   = [Pin 10]
Sensor +V        = [Pin 5V]

Sensor GND     = [Pin GND]

Das Programm liest den aktuellen Status des Sensor-Pins aus und gibt in der seriellen Konsole aus, ob der Hindernis Detektor sich aktuell vor einem Hindernis befindet oder nicht

int Sensor = 10; // Deklaration des Sensor-Eingangspin
   
void setup ()
{
  Serial.begin(9600); // Initialisierung serielle Ausgabe
  pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
}
   
// Das Programm liest den aktuellen Status des Sensor-Pins aus und
// gibt in der seriellen Konsole aus, ob ein Hindernis aktuell erkannt wird
// oder ob kein Hindernis sich vor dem Sensor befindet
void loop ()
{
  bool val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen
   
  if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
  {
    Serial.println("Kein Hindernis");
  }
  else
  {
    Serial.println("Hindernis erkannt");
  }
  Serial.println("------------------------------------");
  delay(500); // Pause zwischen der Messung von 500ms
}



http://www.linkerkit.de/index.php?title=KY-032_Hindernis_Detektor_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



KY-032     Infrarot Objekterkennung


Infrarot Objekterkennung(Abstands-Sensor)

In diesem Post geht es darum, wie man man einen Infrarot Distanzmesser zur Objekterkennung mit dem Arduino verwenden kann. Dadurch kann der Arduino sehr präzise Hindernisse in seiner nahen Umgebung erkennen.

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

Die Verkabelung

Der GND Pin muss mit dem Ground verbunden werden, der Pin eins weiter links ist der Signalpin, und noch eins weiter links befindet sich der Pluspol, welcher mit den +5V des Arduino verbunden werden muss. EN kann frei bleiben.
Sobald der Sensor verbunden ist, ist es einsatzbereit. Dabei kann der Sensor über eine eigene LED anzeigen, ob er ein Objekt erkennt, und zusätzlich kann der Arduino dies über den Signal Pin tun. Am Signalpin wird ein digitales Signal gesendet. LOW steht dabei für Objekt, und HIGH für kein Objekt.
Dabei ist jedoch zu beachten, dass die Reichweite eines Infrarot Sensors geringer ist, als die Reichweite eines Ultraschallsensors. Der Hersteller gibt eine zuverlässige Reichweite von 2 bis 40 cm an. 
Ein weiterer Punkt ist, dass der Sensor nur schwer Objekte mit stark aufgerauten Oberflächen erkennt. Das liegt daran, dass der Sensor Infrarot Licht aussendet. Sollte dieses reflektiert werden, da sich ein Objekt vor dem Sensor befindet, kann er das mit einem Infrarotsensor messen. Bei einer aufgerauten Oberfläche wird jedoch das Licht stark gestreut, wodurch das Objekt nicht erkannt werden kann.

Der Sketch

Im Sketch muss nur überprüft werden, ob der digital Pin auf LOW oder HIGH steht.



void setup() {
Serial.begin(9600);
pinMode(7, INPUT);

}

void loop() {
if(digitalRead(7) == HIGH)
{
Serial.println("Frei!");
}
else {
Serial.println("Objekt erkannt!");
}
}


Infrarot_Objekterkennung_Ardu.ino hosted with ❤ by GitHub



Verwendung

Aufgrund der nur sehr beschränkten Reichweite, sind auch die Einsatzgebiete dieses Sensors beschränkt. Durch die geringe Reichweite eignet er sich jedoch sehr gut, um Objekte zu erkennen. Das ist insbesondere bei bewegten Arduino Robotern sehr interessant, um eine Kollision zu verhindern. 

Außerdem sollte man bei Robotern immer zwei unterschiedliche Sensortechniken, also beispielsweise Infrarot und Ultraschall, verwenden, um die jeweiligen Schwächen auszugleichen und eine verlässliche Messung zu erhalten.



*********************************************************
Hindernis-Detektor Modul KY-032 - wurde nicht geliefert - Dioden schauen nach vorne um ein Hinderniss zu erkennen
Tracking-Sensor Modul KY-033     Dioden schauen nach unten um einer schwarzen Linie zu folgen

3.29   KY-033 - IR-Relexlichtschranke
mit IR Reflektorkoppler TCRT5000 (od. TCRT1000)

Arduino KY-033
Hunt-Sensor-Modul - Avoid
KY-033 Hunt-Sensor-Modul

KY-033 Tracking Sensor Modul
Arduino KY-033 Hunt sensor module
KY-033 Line tracking sensor. Arduino
Arduino - Detecting a White Line With the KY-033
Arduino KY 033 Tracking Sensor Infrared Obstacle Avoidance sensor
KY-033 Tracing Schwarz / White Line Hunting-Sensor-Modul
Tracing Linie Jagd Sensor KY-033 für Arduino:
Optisch : Hunt Sensor Infrarot Modul einstellbar KY-033
KY033: Line follow Sensor Module


KY-033 Hunt sensor module




Anschlussbelegung Arduino:

Sensor Signal       = pin-10
Sensor +V             = +5V]
Sensor GND        = GND

Arduino KY-033 Hunt sensor module
http://www.instructables.com/id/Arduino-Detecting-a-White-Line-With-the-KY-033/


BlackBoard Circuit Designer Schaltplan

Auch für Gabelkoppler CNY70


Module wie dieses werden oft zur Linienverfolgung benutzt.
Das Licht aus der IR-LED wird von einem hellen Untergrund relektiert und vom IR-Transistor empfangen.
Wenn auf dem Untergrund eine breite schwarze Linie aufgezeichnet ist und sich der Sensor darüber beindet, wird kein Licht relektiert.
Mit dem 10k Trimmer lässt sich die Empindlichkeit des Komparators einstellen.
Die LED leuchtet auf, wenn der Relexionssensor Licht empfängt.
Der Ausgang Out liegt beim Komparator bei 5V, wenn kein Licht relektiert wird, und ändert sich in Richtung 0V, wenn das ausgesendete Licht von der Oberläche relektiert wird.






Beispielcode für ARDUINO UNO
Sketch KY-033

int sensorPin = A5;   // select the input pin
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);
}

http://www.instructables.com/id/Arduino-Detecting-a-White-Line-With-the-KY-033/
https://tkkrlab.nl/wiki/Arduino_KY-033_Hunt_sensor_module
https://www.amazon.de/KY-033-Tracing-Hunting-Sensor-Arduino/dp/B00M3IWI3E



Codebeispiel Arduino

Das Programm liest den aktuellen Status des Sensor-Pins aus und gibt in der seriellen Konsole aus, ob der Linetracker sich aktuell auf der Linie befindet oder nicht


int Sensor = 10;               // Deklaration des Sensor-Eingangspin
   
void setup ()
{
  Serial.begin(9600);        // Initialisierung serielle Ausgabe
  pinMode (Sensor, INPUT) ;  // Initialisierung Sensorpin
}
   
   // Das Programm liest den aktuellen Status des Sensor-Pins aus und
   // gibt in der seriellen Konsole aus, ob der Linetracker sich aktuell
   // auf der Linie befindet oder nicht
void loop ()
{
  bool val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen
   
  if (val == HIGH)                 // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
  {
    Serial.println("LineTracker ist ueber der Linie");
  }
  else
  {
    Serial.println("Linetracker ist ausserhalb der Linie");
  }
  Serial.println("------------------------------------");
  delay(500);                     // Pasuse zwischen der Messung von 500ms
}

KY-033_TrackingSensor.zip


http://www.linkerkit.de/index.php?title=KY-033_Tracking_Sensor_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




KY-033   Infrarot Linien Detektor

IR Linien Detektor Sensor

In diesem Post geht es darum, wie man den KY033 Infrarot Linien Detektor Sensor mit dem Arduino verwendet. Durch diesen Sensor, kann der Arduino erkennen, ob der Untergrund hell (Infrarot Licht wird reflektiert) oder dunkel (Infrarot Licht wird absorbiert) ist.

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

Dieser Sensor lässt sich sehr leicht mit dem Arduino verbinden. G muss mit dem Ground verbunden werden, V+ mit +5V und S mit einem beliebigen analogen Eingang des Arduino.

Wie bereits oben erwähnt, basiert das Prinzip des Sensors darauf, dass Infrarot Licht von dunklen Oberflächen absorbiert, und von hellen reflektiert wird. Aus diesem Grund sendet der Sensor laufend Infrarot Licht aus, und misst gleichzeitig die Stärke des reflektierten Infrarot Lichts.

Die Stärke wird dann in eine analog Stromstärke umgewandelt, welche der Arduino dann misst. Dabei steht eine kleine Zahl (~20) für weiß und eine große (~800) für schwarz. Zusätzlich hat der Sensor eine integrierte rote LED, welche bei weißem Untergrund an, und bei schwarzem Untergrund aus ist.

Für einen Arduino Roboter müsst man einfach nur überprüfen, ob der Wert kleiner 100, oder größer 600 ist, um heraus zu finden, ob der Untergrund schwarz oder weiß ist.

Man muss den Sensor relativ nah am Boden halten, da die Reichweite nur ca. 3cm  beträgt.

Wem die Unterscheidung des Untergrunds in hell/dunkel nicht genau genug ist, sollte sich den Farbsensor von Sainsmart genauer ansehen (hier auf Amazon).


Programm siehe KY-032











*********************************************************
3.30   KY-034 - Farbwechsel-LED
Arduino KY-034
Automatisches blinkendes buntes LED-Modul 7 color flash
KY-034 Automatic flashing colorful LED module
KY-034 Automatisches blinkendes buntes LED-Modul




Anschlussbelegung Arduino:

Sensor Signal = pin-13]
Sensor  n.c. =
Sensor GND = pin-GND]

Arduino KY-034 Automatic flashing colorful LED module

7 color flash LED: klare 5mm  LED für direkten 5V Betrieb, die in 7 Farben automatisch nach einem vorgegebenen Ablauf blinkt bzw. langsame Farbübergänge durchläuft.
Pluspol ist auf dem „S“-Anschluss
Minuspol ist auf dem mitteleren Pin


7 Farbe blinkendes LED-Modul automatisch

7 Farbe blinkt LED-Modul automatisch verwendet 5mm runde High-Brightness-Leuchtdiode, die die folgenden Eigenschaften hat:

Technische Daten

     Produkttyp:                LED
     Produkt-Modell:         YB-3120B4PnYG-PM
     Form:                       LED 5mm DIP-Typ
     Farbe: rosafarbenes Gelbgrün (hohe Helligkeit)
     Linsenart:                 weiß matt
     Standard Vorwärtsspannung: 3,0..4,5Vdc

BlackBoard Circuit Designer Schaltplan - Der 10k Widerstand ist überlüssig, da er im Prinzip keinerlei Funktion erfüllt.

Die klare 5mm LED besteht aus 3 LEDs und einer Ansteuerungslogik,
welche die LED automatisch in verschiedenen Farben und Lichtmustern auleuchten lässt.

Die LED hat einen Spannungsbereich von etwa 3V bis 4V und zieht ca. 40mA Strom.
Ein Vorwiderstand ist ratsam, aber nicht unbedingt notwendig, da die LEDs nicht direkt an der Spannungsversorgung liegen, sondern intern angesteuert werden.





Beispielcode für ARDUINO UNO
Sketch KY-034

/*
Blink
Turns on an LED on for two second, then off for two second, repeatedly.
This example code is in the public domain.
*/
 
void setup () {
  // Initialize the digital pin as an output.
  // Pin 13 has an LED connected on most Arduino boards:
  pinMode (13, OUTPUT);
}
void loop () {
  digitalWrite (13, HIGH);  // set the LED on
  delay (2000);             // wait for a second
  digitalWrite (13, LOW);   // set the LED off
  delay (2000);             // wait for a second
}


https://tkkrlab.nl/wiki/Arduino_KY-034_Automatic_flashing_colorful_LED_module
http://learn.linksprite.com/arduino/sensors-kit-for-arduino/ky034-7-colors-led-blinking-module/

http://arduinosensors.nl/index.php?route=product/product&product_id=51


Codebeispiel Arduino

Diese Codebeispiel zeigt auf, wie eine LED mittels eines definierbaren Ausgangspins abwechselnd für  4 Sekunden ein- und danach 2 Sekunden ausgeschaltet werden kann.

int Led = 13;
 
void setup ()
{
  pinMode (Led, OUTPUT);       // Initialisierung Ausgangspin für die LED pin-13
}
 
void loop ()                    //Hauptprogrammschleife
{
  digitalWrite (Led, HIGH);    // LED wird eingeschaltet
  delay (4000);                // Wartemodus für 4 Sekunden
  digitalWrite (Led, LOW);     // LED wird ausgeschaltet
  delay (2000);                // Wartemodus für weitere 2 Sekunden in denen die LED dann ausgeschaltet ist
}

LedTestArduino_4On_2Off.zip
http://www.linkerkit.de/index.php?title=KY-034_7_Farben_LED_Flash-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.31   KY-035 - Magnetfeld-/Hall-Sensor  44E (420)
HAL 501 = HAL 1501
https://www.micronas.com/de/produkte/hall-schalter/hal-5xy




Arduino KY-035 Klasse Bihor magnetischer Sensor - Analog Hall
KY-035 Class Bihor magnetic sensor
KY-035 Klasse Bihor magnetischer Sensor


ARDUINO Hall-Sensor 44E (402)

Hall-Sensor  / Hall Effect Sensors - Allegro  44E = AH44E
  TO-92

BlackBoard Circuit Designer Schaltplan

Hall-Sensoren (nach Edwin Hall) reagieren auf Magnetfelder durch Veränderung der Ausgangsspannung.
Beim Typ HAL5xx beindet sich die empindliche Fläche auf der Vorderseite mit den abgeschrägten Seiten im oberen Drittel in der Mitte, etwa beim oberen Teil des Aufdrucks.
Beim verbauten AH44E (HAL501)  handelt es sich um einen sehr empindlichen, bipolaren Sensor.
Die Ausgangsspannung sinkt ab, wenn der magnetische Südpol zum Sensor hin weist und steigt an, wenn der magnetische Nordpol senkrecht auf den Sensor hin zur Oberläche wirkt.
Die Betriebsspannung liegt im Bereich von 3,8V bis 24 V.
Die Ausgangsspannung des analogen Gebers liegt im Ruhezustand bei etwa der Hälfte der Versorgungsspannung.


Hall Effect Sensor  44E - AH44E - 3144 - A3144 - 3144E - A3144E - OH3144


A3144 A3144E 44E/938 Hall Effect Sensor Switch Magnetic Detector

Beschreibung :
Der verwendete Sensor-IC ist AH44E unipolar digitaler Hall-Effekt-Sensor von allegro.
Die AH44E ist eine kleine, vielseitige lineare Hall-Effekt-Vorrichtung, die vom Magnetfeld aus einem Permanentmagneten oder einem Elektromagneten betrieben wird.

Die Ausgangsspannung wird durch die Versorgungsspannung eingestellt und verhält sich proportional zur Stärke des Magnetfeldes.
Die integrierte Schaltung verfügt über einen geräuscharmen Ausgang, was eine externe Filterung unnötig macht.

Es enthält auch Präzisionswiderstände, um eine erhöhte Temperaturstabilität und Genauigkeit zu bieten. Betriebstemperatur
Bereich dieser linearen Hall-Sensoren ist -40oC bis 85oC, geeignet für kommerzielle, Verbraucher und industrielle Anwendungen.
Der Sensor hat drei Pins pin1-Vcc, pin2-GND und pin3-Output.


Anschlussbelegung Arduino:
Sensor Signal      = pin-A5
Sensor +V             =  5V
Sensor GND        =   GND

Arduino KY-035 Class Bihor magnetic sensor

     Leistungsaufnahme Sensor, nur 8mA

Hall-Sensor mit analogem Ausgangssignal.
Minuspol ist links bei „-“
Pluspol (5V) ist der mittlere Pin.
Der Ausgangspegel liegt an „S“ an.

Analog-Hall-Sensormodul
KY-035 ist ein analoges Magnetfeldsensormodul.
Die Stärke des Feldes ergibt sich aus einer analogen Spannung am Signalstift des Moduls KY-035.

Der Sensor ist an GND und 5V der Arduino-Platine angeschlossen.

Die Ausgangsspannung wird über den Analog pin-A5 auf der Arduino-Platine gemessen.


Das Beispielprogramm misst die Ausgangsspannung des Sensors en den Messwert im seriellen Monitor des Arduino.

Die LED auf der Platine blinkt in Abhängigkeit von der Stärke des Magnetfeldes.
Mit einem kleinen Magnet kann dies demonstriert werden.


Verbindung zum Arduino
     Pin - = GND, an GND des Arduino anschließen
     Pin (mittlerer Stift) +5 V, an Arduino +5 V anschließen
     Pin S-Signal, an Arduino-Pin A5 anschließen



Beispielcode für ARDUINO UNO
Sketch KY-035

Analoges magnetisches Sensormodul und eine digitale Schnittstelle, eingebaute LED pin-13  bilden eine einfache Schaltung, um einen magnetischen Blitz zu produzieren
Makers.13 kommt mit digitalen Schnittstellen der LED, die analoge magnetische Sensor an die Power Board-Analog-5 ARDUINO Schnittstellen angeschlossen, wenn analoge magnetische Sensor zu einem Signal,
LED leuchtet, ansonsten die Lichter aus.

/* 
KY-035 Hall analog sensor
*/
 
int sensorPin = A5;    // select the input pin
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-035_Class_Bihor_magnetic_sensor
http://www.instructables.com/id/Arduino-Magnetic-FIELD-Detector-Using-the-KY-003-o/


KY-035 Bihor Magnet Sensor Modul

Hall-Sensor AH49E

Codebeispiel Arduino

Das Programm misst den aktuellen Spannungswert am Sensor, berechnet aus diesen und dem bekannten Serienwiderstand den aktuellen Widerstandswert des Sensors und gibt die Ergebnisse auf der serielle Ausgabe aus.

int sensorPin = A5; // Hier wird der Eingangs-Pin deklariert
 
// Serielle Ausgabe in 9600 Baud
void setup()
{
    Serial.begin(9600);
}
 
// Das Programm misst den aktuellen Spannungswert am Sensor,
// berechnet aus diesen und dem bekannten Serienwiderstand den aktuellen
// Widerstandswert des Sensors und gibt die Ergebnisse auf der serielle Ausgabe aus
 
void loop()
{     
        // Aktueller Spannungswert wird gemessen...
    int rawValue = analogRead(sensorPin);
        float voltage = rawValue * (5.0/1023) * 1000;
         
        float resitance = 10000 * ( voltage / ( 5000.0 - voltage) );
         
    // ... und hier auf die serielle Schnittstelle ausgegeben
    Serial.print("Spannungswert:"); Serial.print(voltage); Serial.print("mV");
    Serial.print(", Widerstandswert:"); Serial.print(resitance); Serial.println("Ohm");
    Serial.println("---------------------------------------");
 
    delay(500);
}


Single_Analog_Sensor.zip

http://www.linkerkit.de/index.php?title=KY-035_Bihor_Magnet_Sensor_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.32   KY-036 - Berührungssensor mit Komparator
Arduino KY-036
Metall-Berührungssensormodul - Touch    KSP13 oder BC517
KY-036 Metal touch sensor module
KY-036 Metall-Berührungssensormodul

MPSA13 npn  Darlington-Transistor TO-92 30V / 500mA

KSP13  ODER   BC517



Transistor-Sensor  MPSA13-508  Bipolar Darlington Transistor npn  TO-92
MPSA13-308  30V 500mA 625mW



Funktionsweise des Sensors

Dieser Sensor besitzt auf seiner Platine drei funktionelle Bestandteile.
Die Erste ist die Sensoreinheit vorne am Modul, welche das aktuelle Umfeld physikalisch misst und als analoges Signal auf die zweite Einheit, dem Verstärker, ausgibt.
Dieser verstärkt das Signal abhängig vom eingestellten Widerstand am Drehpotentiometer und leitet es auf den analogen Ausgang des Moduls.
Hierbei ist zu beachten:
Das Signal ist invertiert; wird ein hoher Wert gemessen, so resultiert dies in einen niedrigeren Spannungswert am analogen Ausgang.
Die dritte Einheit stellt einen Komparator dar, welcher den digitalen Ausgang und die LED schaltet, wenn das Signal unter einen bestimmten Wert fällt.
Mittels des Drehpotentiometers kann somit die Empfindlichkeit eingestellt werden, wie es im folgenden Bild aufgezeigt wird:


1-Emitter    2-Basis    3-Collektor


Der mittlere Anschlussdraht (2-Basis) ist hier absichtlich um das Gehäuse gebogen.
    1  2  3  4 
pin-A0  GND  +5V  pin-D0

Print 36x15mm

Anschlussbelegung Arduino:


DO digitales Signal   = pin-3
+V                                  = 5V
GND                              = GND
A0 analoges Signal   = pin-A0


Darlington-Transistor  MPSA13 npn
25 Gang Trimmer  100k
Dual-Komparator  LM393

Der Berührungssensor besteht aus einem einfachen Epitaxial Darlington NPN-Transistor vom Typ KSP13, der auch durch einen vergleichbaren Typ wie den BC517 ersetzt werden könnte.
Der Trick besteht darin, dass die Basis als Berührungssensor genutzt wird, weshalb das Anschlussbein auch nach oben um das TO-92 Gehäuse gebogen wurde.
Die Oberlächenspannung genügt, um den Transistor weitestgehend durchzuschalten.
Mit dem Trimmer kann ein Schwellwert für die Empindlichkeit eingestellt werden, bei welchem der Komparator den digitalen Ausgang DO auf 5V ändert.
LED1 leuchtet permanent,
LED2 leuchtet, wenn der Schwellwert erreicht wurde.


BlackBoard Circuit Designer Schaltplan


Arduino KY-036 Metal touch sensor module
Berührungsempfindliche Sensortaste.
Berührt man den Sensor-Pin, liegt am „Out“ Anschluss ein Signal an.
Das Signal ist kein stabiler Pegel, sondern der 50Hz Netzbrumm.
Das Signal ist „high-active“, mit dem Potentiometer kann die Empfindlichkeit eingestellt werden.
Zusätzlich gibt es noch einen analogen Ausgang „A0“.

KEYES ARDUINO Berührungsmodul
Metall-Touch-Interface-Modul und pin-13 LED bauen einen einfachen Schaltkreis zu produzieren eine Touch-Cue-Leuchten pin-13 kommt mit digitalen Schnittstellen der LED,
der Metall-Touch-Sensor angeschlossen digitale drei Schnittstellen, wenn ein Metall-Touch-Sensor ein Tastsignal, LED-LEDs erfasst
, Ansonsten ausgeschaltet.




Beispielcode für ARDUINO UNO
Sketch KY-036

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

https://tkkrlab.nl/wiki/Arduino_KY-036_Metal_touch_sensor_module
http://www.instructables.com/id/Arduino-Touch-Sensor-Switch-Using-the-KY-036/
https://www.pinterest.com/pin/368873025709421259/




Dieser Sensor gibt somit keine absoluten Werte aus (z.B. genau gemessene Temperatur in °C oder Magnetfeldstärke in mT) , sondern es handelt sich hierbei um eine Relativ-Messung:
Man definiert hierbei einen Grenzwert relativ zur gegebenen normalen Umweltsituation und es wird ein Signal ausgegeben was weiterverarbeitet werden kann, falls dieser Grenzwert überschritten bzw. ein anderer Zustand als der Normalfall eingetreten ist.
Dieses Verhalten eignet sich hervorragend zur
Temperaturüberwachung (KY-028),
Näherungsschalter (KY-024, KY-025, KY-036),
Alarmüberwachungen (KY-037, KY-038)
Drehgeber (KY-026).

Codebeispiel Arduino
Das Programm liest den aktuellen Spannungswert aus, der am analogen Ausgang gemessen werden kann, und gibt diesen auf der seriellen Schnittstelle aus.
Zudem wird ebenfalls der Zustand des digitalen Pins in der Konsole angegeben, was bedeutet ob der Grenzwert unterschritten wurde oder nicht.


// Deklaration und Initialisierung der Eingang-Pins
int Analog_Eingang = A0; // X-Achse-Signal
int Digital_Eingang = 3; // Knopf
  
void setup ()
{
  pinMode (Analog_Eingang, INPUT);
  pinMode (Digital_Eingang, INPUT);
       
  Serial.begin (9600); // Serielle Ausgabe mit 9600 bps
}
  
// Das Programm liest die aktuellen Werte der Eingang-Pins
// und gibt diese auf der seriellen Ausgabe aus
void loop ()
{
  float Analog;
  int Digital;
    
  //Aktuelle Werte werden ausgelesen, auf den Spannungswert konvertiert...
  Analog = analogRead (Analog_Eingang) * (5.0 / 1023.0);
  Digital = digitalRead (Digital_Eingang);
    
  //... und an dieser Stelle ausgegeben
  Serial.print ("Analoger Spannungswert:"); Serial.print (Analog, 4);  Serial.print ("V, ");
  Serial.print ("Grenzwert:");
  
  if(Digital==1)
  {
      Serial.println (" erreicht");
  }
  else
  {
      Serial.println (" noch nicht erreicht");
  }
  Serial.println ("----------------------------------------------------------------");
  delay (200);
}



Ard_Analoger_Sensor.zip

http://www.linkerkit.de/index.php?title=KY-036_Metall-Touchsensor_Modul



SCHALTPLAN    Mikrofon KY-037    Mikrofon KY-038    Feuer KY-026     Hall-Sensor KY-024    Berühr-Sensor KY-036     Temperatur KY-028     Reed-Kontakt KY-025
Diese elektronik Module verwendet einen LM393 Dual-Komparator-IC.
Die Sensoren werden zwischen S und G am Eingang links vom Schaltplan angeschlossen.

Das Potentiometer 100k stellt den korrekten Messbereich für das Modul ein.
Sensoren, die + 5V benötigen, können mit den (+) Anschlüssen verbunden werden.

Der Komparator wird auf 1/2 der Versorgungsspannung durch R6 und R2 vorgespannt.

Wenn der Sensor-Schwellwert erreicht ist, geht der Komparatorausgang  Pin-D0 (Digitalausgang) auf HIGH (auf +5 V), wodurch der obere Komparator die LED einschaltet.

Der analoge Spannungswert am Sensoreingang ist an den Pin-A0 (Analogausgang) angeschlossen, wo er mit einem analogen Arduino-Eingang gemessen werden kann.

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-036  Touch Sensor

Touch Sensor

In diesem Post geht es darum, wie man den KY 036 Touch Sensor mit dem Arduino verwendet.


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

Aufbau

Die Verbindung des Touch Sensors mit dem Arduino ist sehr einfach. Der mit G markierte Pin wird mit dem Ground verbunden und + mit +5V. AO steht für analog Output, und DO für digital Output. Am analog Output erhält man ständig ein analoges Signal, und bei DO wird, sobald eine Berührung erkannt wird, was vom Sensor selbst entschieden wird, Pin DO auf HIGH gesetzt.

Bei mir hat die Erkennung sehr gut funktioniert, weshalb ich die Verwendung des digital Ausgangs empfehlen kann.

Verwendung

Um den Sensor mittels dem Arduino auszulesen, muss man nur überprüfen, ob der DO Pin des Sensors auf LOW oder HIGH steht. LOW steht dabei für keinen Kontakt, und HIGH für eine Berührung.

Um anzuzeigen, um der Sensor eine Berührung erkennt, kann man die LED 13 des Arduino verwenden. Zusätzlich jedoch, besitzt das Touch Sensor Modul auch eine eigene rote LED, welche bei Berührung aufleuchtet.

Als Alternative zu diesem Sensor kann man sich auch einen Selbstbau Touchsensor bauen. Auch dieser Touch Sensor ist kapazitativ. Das bedeutet schon eine leichte Berührung reicht aus, für ein Signal, und man muss den Sensor nicht fest drücken.

touch_sensor_ardu.ino hosted with ❤ by GitHub

Ein einfacher Beispielsketch zum Auslesen sieht etwa so aus:


void setup ()
{
pinMode (13, OUTPUT) ;
pinMode (3, INPUT) ;
}

int val;

void loop ()
{
val = digitalRead (3) ;
if(val == HIGH) //Bei Beruehrung
{
digitalWrite (13, HIGH); //LED AN
}
else
{
digitalWrite (13, LOW); //LED AUS
}
}






*********************************************************
3.33 KY-037 - Mikrofon
Arduino KY-037
Empfindliches Mikrofonsensor-Modul - Big sound - 10mm  2-pin

KY-037 Sensitive microphone sensor module
KY-037 Empfindliches Mikrofonsensormodul

High Sensitivity Microphone Sound Sensor Module Keyes KY-037
LM393 - Low Offset Voltage Dual Comparators
LM393 - Low power dual voltage comparator

https://www.mikrocontroller.net/part/LM393
http://www.datasheetbay.com/pdf/927431/KY-038.html

Arduino KY-037 Sensitive microphone sensor module
pin-AO
    GND
       +5V
          pin-D0

Print 36x15mm




Bei dem Modul KY-037 mit der 10mm großen Elektret-Kondensator-Mikrofonkapsel handelt es sich um einen akustischen Schallsensor mit geringer Empindlichkeit.
Mittels des Trimmers kann für die Empindlichkeit ein Schwellwert eingestellt werden, bei dem der Komparator den digitalen Ausgang DO auf 5,0V ändert.
So kann das Modul beispielsweise auf Händeklatschen oder laute Geräsche / Klatschen reagieren.
LED1 leuchtet permanent,
LED2 leuchtet, wenn der Schwellwert erreicht wurde.


BlackBoard Circuit Designer Schaltplan

Anschlussbelegung Arduino:
digitales Signal    = pin-3
+V                        = +5,0Vdc
GND                     = GND
analoges Signal   = pin-A0


Dieser Sensor besitzt auf seiner Platine drei funktionelle Bestandteile.
Die ist erstens die Mikrofoneinheit vorne am Modul, welche das aktuelle Umfeld physikalisch misst und als analoges Signal auf die zweite Einheit, dem Verstärker, ausgibt.
Dieser verstärkt das Signal abhängig vom eingestellten Widerstand am Drehpotentiometer und leitet es auf den analogen Ausgang des Moduls.
Hierbei ist zu beachten:
Das Signal ist invertiert; wird ein hoher Wert gemessen, so resultiert dies in einen niedrigeren Spannungswert am analogen Ausgang.
Die dritte Einheit stellt einen Komparator dar, welcher den digitalen Ausgang und die LED schaltet, wenn das Signal unter einen bestimmten Wert fällt.
Mittels des Drehpotentiometers kann somit die Empfindlichkeit eingestellt werden, wie es im folgenden Bild aufgezeigt wird:


Digitaler Ausgang:
Über das Potentiometer, kann ein Grenzwert für den empfangenen Schall eingestellt werden, bei dem der digitale Ausgang schalten soll.
Analoger Ausgang:
Direktes Mikrofon-Signal als Spannungspegel
LED1:
Zeigt an, dass der Sensor mit Spannung versorgt ist
LED2:
Zeigt an, dass ein Magnetfeld detektiert wurde




„Big Sound“ Mikrofonmodul mit 10mm ECM Electret-Kapsel.
Bei Erreichen eines bestimmten Lautstärkepegels schaltet der Ausgang  pin-DO (high active).
Die Schaltschwelle kann mit dem Poti nach Bedarf justiert werden.
Der analoge Pegel kann am Analog-Anschluss pin-A0 abgegriffen werden.
Bis auf die kleinere Mikrofonkapsel und geringere Empfindlichkeit ist das Modul identisch zum „Small sound“ Modul.

Inhalt
     1 Mikrofon-Sound-Erkennungsmodul
     2 Anschließen an das Arduino
     3 Beispielcode: Digitalausgang
     4 Beispielcode: Analogausgänge

Mikrofon-Sound-Erkennungsmodul
Für Schalldetektion hat das Modul zwei Ausgänge:
     AO, Analogausgang, Echtzeit-Ausgangsspannungssignal des Mikrofons
     DO, wenn die Schallintensität einen bestimmten Schwellenwert erreicht, das Ausgangssignal hoch und niedrig

Die Schwellwertempfindlichkeit kann über Potentiometer am Sensor eingestellt werden
Verbindung zum Arduino
     Pin + auf Arduino +5Vdc
     Pin - nach Arduino GND
     Pin-AO zu Arduino pin-A0 (für Analogprogramm)
     Pin-DO an Arduino pin-13 (für digitales Programm)


Beispielcode digital Ausgang
Sketch KY-037/1

int Led = 13 ;      // define LED Interface
int buttonpin = 3;  // define D0 Sensor Interface
int val = 0;        // define numeric variables val
 
void setup ()
{
  pinMode (Led, OUTPUT) ;      // define LED as output interface
  pinMode (buttonpin, INPUT) ; // output interface D0 is defined sensor
}
 
void loop ()
{
  val = digitalRead(buttonpin);// digital interface will be assigned a value of pin 3 to read val
  if (val == HIGH)             // When the sound detection module detects a signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}



Beispielcode analog Ausgang
Sketch KY-037/2

int sensorPin = A0;  // 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-037_Sensitive_microphone_sensor_module
https://tkkrlab.nl/wiki/Arduino_KY-037_Sensitive_microphone_sensor_module
https://learn.adafruit.com/adafruit-microphone-amplifier-breakout/measuring-sound-levels


KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit

Dieser Sensor gibt somit keine absoluten Werte aus
(z.B. genau gemessene Temperatur in °C oder Magnetfeldstärke in mT)
 sondern es handelt sich hierbei um eine Relativ-Messung:
Man definiert hierbei einen Grenzwert relativ zur gegebenen normalen Umweltsituation und es wird ein Signal ausgegeben was weiterverarbeitet werden kann, falls dieser Grenzwert überschritten bzw. ein anderer Zustand als der Normalfall eingetreten ist.
Dieses Verhalten eignet sich hervorragend zur
Temperaturüberwachung (KY-028),
Näherungsschalter (KY-024, KY-025, KY-036),
Alarmüberwachungen (KY-037, KY-038)
Drehgeber (KY-026)

Codebeispiel Arduino

Das Programm liest den aktuellen Spannungswert aus, der am analogen Ausgang gemessen werden kann, und gibt diesen auf der seriellen Schnittstelle aus.
Zudem wird ebenfalls der Zustand des digitalen Pins in der Konsole angegeben, was bedeutet ob der Grenzwert unterschritten wurde oder nicht.


// Deklaration und Initialisierung der Eingang-Pins
int Analog_Eingang = A0; // X-Achse-Signal
int Digital_Eingang = 3; // Knopf
  
void setup ()
{
  pinMode (Analog_Eingang, INPUT);
  pinMode (Digital_Eingang, INPUT);
       
  Serial.begin (9600); // Serielle Ausgabe mit 9600 bps
}
  
// Das Programm liest die aktuellen Werte der Eingang-Pins
// und gibt diese auf der seriellen Ausgabe aus
void loop ()
{
  float Analog;
  int Digital;
    
  //Aktuelle Werte werden ausgelesen, auf den Spannungswert konvertiert...
  Analog = analogRead (Analog_Eingang) * (5.0 / 1023.0);
  Digital = digitalRead (Digital_Eingang);
    
  //... und an dieser Stelle ausgegeben
  Serial.print ("Analoger Spannungswert:"); Serial.print (Analog, 4);  Serial.print ("V, ");
  Serial.print ("Grenzwert:");
  
  if(Digital==1)
  {
      Serial.println (" erreicht");
  }
  else
  {
      Serial.println (" noch nicht erreicht");
  }
  Serial.println ("----------------------------------------------------------------");
  delay (200);
}


Ard_Analoger_Sensor.zip

http://www.linkerkit.de/index.php?title=KY-037_Mikrofon_Sensor_Modul_-_hohe_Empfindlichkeit



SCHALTPLAN    Mikrofon KY-037    Mikrofon KY-038    Feuer KY-026     Hall-Sensor KY-024    Berühr-Sensor KY-036     Temperatur KY-028     Reed-Kontakt KY-025
Diese elektronik Module verwendet einen LM393 Dual-Komparator-IC.
Die Sensoren werden zwischen S und G am Eingang links vom Schaltplan angeschlossen.

Das Potentiometer 100k stellt den korrekten Messbereich für das Modul ein.
Sensoren, die + 5V benötigen, können mit den (+) Anschlüssen verbunden werden.

Der Komparator wird auf 1/2 der Versorgungsspannung durch R6 und R2 vorgespannt.

Wenn der Sensor-Schwellwert erreicht ist, geht der Komparatorausgang  Pin-D0 (Digitalausgang) auf HIGH (auf +5 V), wodurch der obere Komparator die LED einschaltet.

Der analoge Spannungswert am Sensoreingang ist an den Pin-A0 (Analogausgang) angeschlossen, wo er mit einem analogen Arduino-Eingang gemessen werden kann.

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.34   KY-038 - Mikrofon
Arduino KY-038
Mikrofon-Schallsensormodul - Small sound - 6mm  3-pin
KY-038 Microphone sound sensor module
KY-038 Mikrofon-Schallsensormodul


Das Modul unterscheidet sich nur die geringere Empindlichkeit und der kleineren  Größe (6mm) des ECM = Elektretmikrofons vom Modul KY-037.


                                pin-AO
                                       GND
                                             +5V
                                                 pin-DO

Print 36x15mm

Arduino KY-038 Microphone sound sensor module

„Small Sound“ Mikrofonmodul mit kleiner 6mm ECM Electret-Kapsel.
Bei Erreichen eines bestimmten Lautstärkepegels schaltet der Ausgang „DO“ (high active).
Die Schaltschwelle kann mit dem Poti nach Bedarf justiert werden.
Der analoge Pegel kann am Anschluss „AO“ abgegriffen werden.
Bis auf die kleinere Mikrofonkapsel und geringere Empfindlichkeit ist das Modul identisch zum „Big sound“ Modul.

BlackBoard Circuit Designer Schaltplan


Inhalt
     1 Mikrofon-Sound-Erkennungsmodul
     2 Anschließen an das Arduino
     3 Beispielcode: Digitalausgang
     4 Beispielcode: Analogausgänge

Mikrofon-Sound-Erkennungsmodul
Für Schalldetektion Das Modul hat zwei Ausgänge:
     AO, Analogausgang, Echtzeit-Ausgangsspannungssignal des Mikrofons
     DO, wenn die Schallintensität einen bestimmten Schwellenwert erreicht, das Ausgangssignal hoch und niedrig

Die Schwellwertempfindlichkeit kann über Potentiometer am Sensor eingestellt werden
Verbindung zum Arduino

     Pin + auf Arduino +5Vdc
     Pin - nach Arduino GND
     Pin-AO zu Arduino pin-A0 (Analog)
     Pin-DO an Arduino pin-13 (Digital)




Beispielcode digital Ausgang
Sketch KY-038/1

int Led = 13 ;      // define LED Interface
int buttonpin = 3;  // define D0 Sensor Interface
int val = 0;        // define numeric variables val
 
void setup ()
{
  pinMode (Led, OUTPUT) ;      // define LED as output interface
  pinMode (buttonpin, INPUT) ; // output interface D0 is defined sensor
}
 
void loop ()
{
  val = digitalRead(buttonpin);// digital interface will be assigned a value of pin 3 to read val
  if (val == HIGH) // When the sound detection module detects a signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}


Beispielcode digital Ausgang
Sketch KY-038/2
int sensorPin = A0;  // 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);
}





SCHALTPLAN    Mikrofon KY-037    Mikrofon KY-038    Feuer KY-026     Hall-Sensor KY-024    Berühr-Sensor KY-036     Temperatur KY-028     Reed-Kontakt KY-025
Diese elektronik Module verwendet einen LM393 Dual-Komparator-IC.
Die Sensoren werden zwischen S und G am Eingang links vom Schaltplan angeschlossen.

Das Potentiometer 100k stellt den korrekten Messbereich für das Modul ein.
Sensoren, die + 5V benötigen, können mit den (+) Anschlüssen verbunden werden.

Der Komparator wird auf 1/2 der Versorgungsspannung durch R6 und R2 vorgespannt.

Wenn der Sensor-Schwellwert erreicht ist, geht der Komparatorausgang  Pin-DO (Digitalausgang) auf HIGH (auf +5V), wodurch der obere Komparator die LED einschaltet.

Der analoge Spannungswert am Sensoreingang ist an den Pin-A0 (Analogausgang) angeschlossen, wo er mit einem analogen Arduino-Eingang gemessen werden kann.


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-038   Mikrofone        6mm und 10mm

Mikrofon

In diesem Post geht es darum, wie man ein Mikrofon mit dem Arduino verwendet. Dadurch kann er Geräusche erkennen.

Dieser Post ist Teil der Artikelserie über das Ultimate Arduino Sensor Kit mit 37 Sensoren. Das Kit, inklusive Mikrofonen, gibt es hier auf Amazon.  Das Mikrofon, mit der großen Membran, einzeln findet ihr hier auf Amazon.

Die Verbindung mit dem Arduino

Beide Mikrofone unterstützen genau die selben Funktionen, sind jedoch für unterschiedliche Schallgrößen ausgelegt. In der Praxis, unter normalen Bedingungen, ist jedoch das Mikrofon mit der großen Membran (auf dem Bild rechts) besser geeignet.

Um es mit dem Arduino zu verbinden, muss man Pin G mit dem Ground verbinden, + mit den +5V des Arduino und DO mit einem digital Pin des Arduino. Sobald das Mikrofon mit Strom versorgt ist, leuchten zwei rote LEDs. 

Die Eine signalisiert, dass das Mikrofon an ist, die Andere zeigt an, ob das Mikrofon einen Ton erkennt. Dabei leuchtet sie, wenn das Mikrofon einen gewissen Geräuschpegel misst. Nun sind jedoch die Mikrofon werksseitig normalerweise leider auf einen falschen Wertebereich eingestellt und aktivieren auch bei Stille die LED.

Um das zu ändern, muss man die kleine Schraube auf dem blauen Quader auf dem Modul gegen den Uhrzeigersinn drehen. Das muss man solange tun, bis die zweite rote LED bei Ruhe (oder beim vorhergesehenen Normalpegel) gerade nicht mehr leuchtet. Das sind einige Umdrehungen.

Nun kann man auch mit dem Arduino messen, ob sich die Lautstärke verändert hat. Dabei steht LOW für unter dem eingestellten Geräuschpegel, und HIGH für darüber. Ein genaueres Auslesen ist mit diesen Mikrofonen und dem Arduino nicht möglich.

Verwendung

Durch die Möglichkeit den Normalpegel über die kleine Schraube selbst einzustellen, gibt es viele mögliche Einsatzgebiete für ein Mikrofon in unterschiedlichen lauten Bereichen.

Beispiele wären eine Lärmampel, oder die Verwendung mitsamt einem Infrarot Bewegungssensor zur effektiven Überwachung von Räumen.


Der Sketch

Im Arduinosketch muss man nur überprüfen, ob der jeweilige Signalpin auf LOW oder HIGH steht.
microphone_ardu.ino hosted with ❤ by GitHub



void setup() {
pinMode(2, INPUT);
Serial.begin(9600);

}

void loop() {
if(digitalRead(2) == HIGH)
{
Serial.println("Laerm!");
}
else
{
Serial.println("Ruhe...");
}
delay(10);
}




*********************************************************
3.25 KY-039 - Fingerkuppenherzschlagfühler
Arduino KY-039
Erkennen Sie das Heartbeat-Modul - Heartbeat - SFH203

Keyes 039 – Pulse Rate Sensor Module

Pulsmesser am Finger

SFH 203 P SFH 203 PFA Silizium-PIN-Fotodiode

KY-039 Herzschlag Sensor Modul
KY-039 Detect the heartbeat module
KY-039 Ermitteln Sie das Heartbeat-Modul


OBEN IR-emierende LED Dm 5mm
Print 18,5x15mm

UNTEN flacher 4x2,5mm  IR Foto-Transistor

Anschlussbelegung Arduino:
Sensor Signal       =  pin-A0
Sensor +V              = 5V
Sensor -                 = GND



BlackBoard Circuit Designer Schaltplan

Arduino KY-039 Detect the heartbeat module

Heartbeat-Sensor, besteht aus einer IR-LED und einem Fototransistor und kann den Puls an der Fingerspitze messen, wenn der Finger zwischen die beiden Bauelemente gehalten wird.
Das Modul benötigt externe Beschaltung.
Ein 330R Vorwiderstand für die LED ist bereits enthalten.
Der mittlere Pin kommt an +5V
Minus ist an den „-“ pin-7
Signal des Fototransistors liegt am linken „S“ Pin an.
eingebauter 10kOhm Pull-up Widerstand



IR-LED SFH487                     Osram SFH487-2 - IR LED 880 nm 3 mm

SFH203FA Fotodiode, 100µA / 740 .. 1100nm
http://www.elektronik-kompendium.de/sites/bau/0111021.htm

IR-Fototransitor SFH309FA   SFH 309 FA: Fototransistor, 0,4mA - 35V - 730-1100nm
http://www.elektronik-kompendium.de/sites/bau/0207012.htm


Fotodioden haben ein lineares Ausgangssignal. Eignen sich also zum Messen der Helligkeit. Haben ein kleines Ausgangssignal.
Fototransistoren sind deutlich nichtlinearer. Haben ein großes Ausgangssignal, kann man also direkt an den Mikrocontroller anschließen.

Ideal ist: Fotodiode + Verstärker. Linear und großes Ausgangssignal.
Fototransistoren sind im Prinzip Fotodioden mit anschließendem Transistor. Fototransistoren sind auch langsamer als Fotodioden. Für Fotodioden verwendet man üblicherweise einen Transimpedanzverstärker, wobei die Fotodiode im Kurzschlussbetrieb verwendet wird.
Photodioden sind eine Stromquelle. Sollarzellen sind Photodioden http://de.wikipedia.org/wiki/Photodiode Bei Phototransistoren wird der Basisstrom nicht über den Basisanschluß injiziert sondern durch den Photoeffekt in der Basisschicht bei Beleuchtung. http://de.wikipedia.org/wiki/Phototransistor

Bei einer Fotodiode werden durch Lichteinfall auf die Sperrschicht Elektronen und Löcher erzeugt.
Hierdurch kommt es dann zu einem Stromfluss von der p-Schicht zur n-Schicht.

Ein Fototransistor ist ja im Grunde ein "normaler" Transistor, bei dem der Basis-Anschluss (in der Regel) durch Licht ersetzt wird.
Licht ist quassi der Basis-Anschluss und steuert den Fototransistor.
Bei Lichteinfall findet dann zwischen dem Kollektor-Anschluss und dem Emitter-Anschluss ein Stromfluss statt.
Also fließt ein Strom von der n-Schicht über die p-Schicht.
Dadurch wird die zweite n-Schicht leitet und es fließt eine Strom.


Hierbei handelt es sich um eine IR-Lichtschranke:
Die IR-LED (mit Vorwiderstand)
(Typnummer LED unbekannt, eventuell SFH203) beleuchtet den IR-Fototransistor .
Wenn ein Finger zwischen Sender und Empfänger gehalten wird, verändert das durch den Finger strömende Blut die empfangene Lichtintensität.
Der Ausgang S ist durch den Pull-Up-Widerstand Low-Aktiv.
Die Funktionsfähigkeit des Moduls ist stark eingeschränkt und aus technischer Sicht eher nicht gegeben.

Fingerpusmesser - Finger Pulsoximeter - Finger-Pulsmessgerät - Fingerpulsoximeter - Oximeter - Pulsmesser,

Wird ein Finger zwischen der Infrarot-Leuchtdiode und dem Foto-Transistor gehalten, so kann am Signalausgang der Puls detektiert werden.
Die Funktionsweise eines Fototransistors ist wie folgt erklärt: Dieser funktioniert in der Regel wie ein normaler Transistor - so wird ein höherer Strom durch ihn durchgelassen, je höher die Steuerspannung ist, die an ihn angelegt wird.
Bei einem Fototransistor stellt jedoch das einfallende Licht die Steuerspannung dar - je höher das einfallende Licht, so höher der durchgelassene Strom.
Der bei diesem Sensormodul aufgebaute Messaufbau mit Infrarotdiode und Fototransistor ermöglicht uns nun den Puls zu messen, indem ein Finger zwischen Diode und Transistor gelegt wird. Erklärung:
Genau so wie man es von der Taschenlampe kennt, kann die Haut an der Hand durchleuchtet werden.
Trifft man beim Durchleuchten auf eine Blutader, so kann man ganz schwach das Pumpen des Blutes erkennen.
Dieses Pumpen erkennt man, da das Blut an unterschiedlichen Stellen in der Ader eine andere Dichte besitzt und somit Helligkeitsunterschiede beim Blutfluss erkennbar sind.
Genau diese Unterschiede in der Helligkeit kann man mit dem Sensormodul aufnehmen und somit den Puls erkennen.
Zudem sollte beim messen am besten der kleine Finger verwendet werden, sowie darauf geachtet werden, dass zwischen Diode und Transistor kein blockierender Knochen sondern eher größenteils die Haut aufgenommen wird.

Pulsoximeter:
 Es wird die Änderung der Durchläßigkeit für Licht von Körperteilen gemessen.
Diese änder sich mit der Menge des Blutes in den Kapillargefäßen durch den Herzschlag.
Bei Erwachsenen hat man dazu Fingersensoren oder solche für das Ohrläppchen.
Bei Säuglingen und Frühgeburten hat man flexible Sensoren die dann an der Ferse oder am Fuß, auch am Handballen mit medizinischen Klebestreifen geklebt werden.
Die Meßsonde sind einfach 2 LED (rot und infrarot) und ein Empfänger Fototransistor

881_c_1OC-1Pot-3Led-2T-2IC-5V_080831-11 SFH309FA NE555 LM358N Stress-o-Meter FingerPulsMesser_1a.pdf


Herzschlagmodul am Finger messend
Dieses Projekt verwendet helle Infrarot (IR) LED und einen Fototransistor, um den Puls des Fingers zu erkennen, eine rote LED blinkt mit jedem Puls.
Puls-Monitor arbeitet wie folgt:
Die LED ist die Lichtseite des Fingers, und Fototransistor auf der anderen Seite des Fingers, Phototransistor verwendet,
um den Fluss zu erhalten, emittiert, wenn der Blutdruck Puls durch den Finger, wenn der Widerstand des Fototransistors wird
Werden.
Die schematische Schaltung des Projekts wie gezeigt, haben wir einen sehr hohen Widerstand Widerstand R1 gewählt,
weil der größte Teil des Lichts durch den Finger absorbiert wird, ist es wünschenswert, dass der Phototransistor empfindlich genug ist.

Widerstand kann durch Experiment ausgewählt werden, um die besten Ergebnisse zu erzielen.

Das wichtigste ist, das Schirmstreulicht in den Phototransistor zu halten.

Für Heimbeleuchtung, die besonders wichtig ist, weil die Lichter zu Hause meist basiert 50Hz fluktuieren, so schwacher Herzschlag wird erhebliche Lärm hinzuzufügen.

Beim Programmablauf werden die Messwerte ausgedruckt.
Um einen echten Herzschlag von diesem könnte eine Herausforderung sein.

Verbindung zum Arduino
    
Sensorstift S an Arduino-Pin anschließen Analog 0  pin-A0
    
Sensorstift + (mittlerer Stift) an Arduino pin+5V anschließen
    
Sensorstift - mit Arduino-Stift GND verbinden


Beispielcode für ARDUINO UNO
Sketch KY-039
                      // Pulse Monitor Test Script
int sensorPin = 0;
double alpha = 0.75;
int period = 100;
double change = 0.0;
double minval = 0.0;
void setup ()
{
  Serial.begin (9600);
}
void loop ()
{
    static double oldValue = 0;
    static double oldChange = 0;
 
    int rawValue = analogRead (sensorPin);
    double value = alpha * oldValue + (1 - alpha) * rawValue;
 
    Serial.print (rawValue);
    Serial.print (",");
    Serial.println (value);
    oldValue = value;
 
    delay (period);
}


https://tkkrlab.nl/wiki/Arduino_KY-039_Detect_the_heartbeat_module
http://www.instructables.com/id/Arduino-Simple-Heart-Beat-Monitor-With-LCD1602A-Us/


KY-039 Herzschlag Sensor Modul

Codebeispiel Arduino

Das folgende Code-Beispiel stammt aus der Feder von Dan Truong, welcher diesen Code unter [folgenden Link] veröffentlicht hat.
Dieser steht unter der [|MIT OpenSource Lizenz] zur Verfügung.
Die unten stehende Version ist die übersetzte deutsche Fassung - das original steht unten zum Download zur Verfügung.
Dieser Code stellt eine sog. Peak-Detection dar. Es wird kein Herzschlagverlauf aufgezeichnet, sondern es wird innerhalb der aufgezeichneten Daten nach "Peaks" (Spitzen) gesucht, als Herschlag erkannt und per LED angezeigt.
Mittels der bekannten Delay Abstände, kann somit grob der Puls errechnet werden.
Wird der Finger beim messen neu aufgelegt oder stark bewegt, so kann es etwas dauern, bis das Programm sich auf die neue Gegebenheit kalibriert und wieder den richtigen Wert ausgibt.

////////////////////////////////////////////////////////////////////////
/// Copyright (c)2015 Dan Truong
/// Permission is granted to use this software under the MIT
/// licence, with my name and copyright kept in source code
///
/// KY039 Arduino Heartrate Monitor V1.0 (April 02, 2015)
////////////////////////////////////////////////////////////////////////
 
// German Comments by Joy-IT
 
 
////////////////////////////////////////////////////////////////////////
/// @param[in] IRSensorPin Analog PI an welchen der Sensor angeschlossen ist
/// @param[in] delay (msec) Die Verzoegerung zwischen den Aufrufen der Abtastfunktion.
//                   Die besten Ergebnisse erhaelt man, wenn man 5 mal Pro Herzschlag abtastet.
///                  Nicht langsamer als 150mSec für z.B. 70 BPM Puls
///                  Besser waere 60 mSec für z.B. bis zu einen Puls von 200 BPM.
///
/// @Kurzbeschreibung
/// Dieser Code stellt eine sog. Peak-Detection dar.
/// Es wird kein Herzschlagverlauf aufgezeichnet, sondern es
/// wird innerhalb der aufgezeichneten Daten nach "Peaks" (Spitzen) gesucht,
/// und per LED angezeigt. Mittels der bekannten Delay Abstaende, kann somit
/// grob der Puls errechnet werden.
////////////////////////////////////////////////////////////////////////
 
int rawValue;
 
 
bool
heartbeatDetected(int IRSensorPin, int delay)
{
  static int maxValue = 0;
  static bool isPeak = false;
   
   
  bool result = false;
     
  rawValue = analogRead(IRSensorPin);
  // Hier wird der aktuelle Spannungswert am Fototransistor ausgelesen und in der rawValue-Variable zwischengespeichert
  rawValue *= (1000/delay);
 
  // Sollte der aktuelle Wert vom letzten maximalen Wert zu weit abweichen
  // (z.B. da der Finger neu aufgesetzt oder weggenommen wurde)
  // So wird der MaxValue resetiert, um eine neue Basis zu erhalten.
  if (rawValue * 4L < maxValue) {    maxValue = rawValue * 0.8;  }    // Detect new peak  if (rawValue > maxValue - (1000/delay)) {
    // Hier wird der eigentliche Peak detektiert. Sollte ein neuer RawValue groeßer sein
    // als der letzte maximale Wert, so wird das als Spitze der aufgezeichnten Daten erkannt.
    if (rawValue > maxValue) {
      maxValue = rawValue;
    }
    // Zum erkannten Peak soll nur ein Herzschlag zugewiesen werden
    if (isPeak == false) {
      result = true;
    }
    isPeak = true;
  } else if (rawValue < maxValue - (3000/delay)) {
    isPeak = false;
    // Hierbei wird der maximale Wert bei jeden Durchlauf
    // etwas wieder herabgesetzt. Dies hat den Grund, dass
    // nicht nur der Wert sonst immer stabil bei jedem Schlag
    // gleich oder kleiner werden wuerde, sondern auch,
    // falls der Finger sich minimal bewegen sollte und somit
    // das Signal generell schwaecher werden wuerde.
    maxValue-=(1000/delay);
 }
  return result;
}
 
 
////////////////////////////////////////////////////////////////////////
// Arduino main code
////////////////////////////////////////////////////////////////////////
int ledPin=13;
int analogPin=0;
 
void setup()
{
  // Die eingebaute Arduino LED (Digital 13), wird hier zur Ausgabe genutzt
  pinMode(ledPin,OUTPUT);
   
  // Serielle Ausgabe Initialisierung
  Serial.begin(9600);
  Serial.println("Heartbeat Detektion Beispielcode.");
}
 
const int delayMsec = 60; // 100msec per sample
 
// Das Hauptprogramm hat zwei Aufgaben:
// - Wird ein Herzschlag erkannt, so blinkt die LED kurz auf
// - Der Puls wird errechnet und auf der serriellen Ausgabe ausgegeben.
 
void loop()
{
  static int beatMsec = 0;
  int heartRateBPM = 0;
      Serial.println(rawValue);
  if (heartbeatDetected(analogPin, delayMsec)) {
    heartRateBPM = 60000 / beatMsec;
    // LED-Ausgabe bei Herzschlag
    digitalWrite(ledPin,1);
 
    // Serielle Datenausgabe
    Serial.print(rawValue);
    Serial.print(", ");
    Serial.println(heartRateBPM);
     
    beatMsec = 0;
  } else {
    digitalWrite(ledPin,0);
  }
  delay(delayMsec);
  beatMsec += delayMsec;
}


KY-039-HeartBeatDetector deutsche Version by Joy-It
KY-039-HeartBeatDetector original by DanTruong
http://www.linkerkit.de/index.php?title=KY-039_Herzschlag_Sensor_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


Herzfrequenzmessung von der Fingerspitze

Heart rate measurement from fingertip

Die Signalkonditionierungsschaltung besteht aus zwei identischen aktiven Tiefpaßfiltern mit einer Grenzfrequenz von etwa 2,5 Hz.
Dies bedeutet, dass die maximal messbare Herzfrequenz etwa 150 Pulse / Minute beträgt.

Der Operationsverstärker IC, der in dieser Schaltung verwendet wird, ist MCP602, ein dualer OpAmp-Chip von Microchip.

Es arbeitet mit einer einzigen Stromversorgung und stellt eine Rail-to-Rail-Ausgangsschwingung bereit.

Die Filterung ist erforderlich, um jegliche in dem Signal vorhandenen höheren Frequenzgeräusche zu blockieren.
Die Verstärkung jeder Filterstufe wird auf 101 eingestellt, was eine Gesamtverstärkung von etwa 10000 ergibt.
Ein 1uF Kondensator am Eingang jeder Stufe ist erforderlich, um die Gleichspannungskomponente im Signal zu sperren.

Die Gleichungen zur Berechnung von Verstärkung und Grenzfrequenz des aktiven Tiefpaßfilters sind im Schaltplan dargestellt.

Der zweistufige Verstärker / Filter liefert ausreichend Verstärkung, um das schwache Signal, das von der Fotosensoreinheit kommt, zu verstärken und es in einen Impuls umzuwandeln.

Eine am Ausgang angeschlossene LED blinkt bei jedem erkannten Herzschlag.

Der Ausgang des Signalkonditionierers geht zum T0CKI-Eingang des PIC16F628A.




Schaltplan    IR-Sensoren und Signalaufbereitung

Der Steuer- und Anzeigeteil der Schaltung ist nachstehend gezeigt.
Die Anzeigeeinheit umfasst ein 3-stelliges gemeinsames Anoden-, 7-Segment-Modul, das unter Verwendung einer Multiplextechnik angetrieben wird.
Die Segmente a-g werden durch die PORTB-Stifte RB0-RB6 angetrieben.
Die Einheiten-, Zehn- und Hunderterziffern werden mit RA2-, RA1- und RA0-Anschlussstiften gemultiplext.

Ein Taktschalter-Eingang ist mit dem RB7-Pin verbunden.
Damit wird die Herzfrequenzmessung gestartet. Sobald der Startknopf gedrückt wird, aktiviert der Mikrocontroller die IR-Übertragung in der Sensoreinheit für 15 Sek. Während dieses Intervalls wird die Anzahl der am T0CKI-Eingang ankommenden Impulse gezählt.
Die tatsächliche Herzfrequenz wäre 4 mal den Zählwert, und die Auflösung der Messung wäre 4. Sie können sehen, die IR-Übertragung wird durch RA3 Pin von PIC16F628A gesteuert.

Der Mikrocontroller läuft bei 4,0 MHz mit einem externen Kristall.
Eine geregelte + 5V Stromversorgung wird von einer externen 9 V Batterie mit einem LM7805 Regler IC abgeleitet.

http://embedded-lab.com/blog/heart-rate-measurement-from-fingertip/




*********************************************************
3.26   KY-040 - Drehencoder mit Drucktaster
Arduino KY-040
Drehgebermodul - Rotary encoder
KY-040 Rotary encoder module
KY-040 Drehgebermodul

Arduino Drehregler Drehgeber Rotary Encoder Push button KY-040 31X19X29mm

Mit dem Drehregler für Ihre Arduino-Anwendung können Sie verschiedenste Einstellungen im Fingerumdrehen durchführen.
Der Drehregler ist aus Metall und kann auch gedrückt werden und bietet somit mehr Programmier- und Nutzungsmöglichkeiten.
Dieses wertige Bauteil hat einen festen Druckpunkt und einen angenehmes Gefühl beim Drehen des Controllers.
Außerdem ist er besonders kompakt - seine Maße betragen nur 25,4x19mm.


Das Modul hat 5 Anschlüsse: CLK, DT, SW, + & GND.

  • Modell: KY-040
  • 20 Pulse pro Umdrehung
  • 5,4Vcc Betriebsspannung
  • Ausgänge: Clock (Takt/Impulse), Direction (Drehrichtung), Switch
  • Versorgungsspannungseingang


                                  GND
                                       +5V
                                          SW
                                              DT
                                                 CLK
Print 25,4x19mm

Anschlussbelegung Arduino:


CLK                = pin-3
DT                  = pin-4
Button           = pin-5
+                    = 5Vdc
GND             = GND

Arduino KY-040 Rotary encoder module
Dreh-Encoder zum Aufbau elektronischer Potis usw., die Anschlüsse sind auf der Platine beschriftet.

Ein Drehgeber erzeugt über zwei interne Schaltkontakte einen Signalcode (meistens Graycode), der die Drehrichtung widerspiegelt, weil die Kontakte zu unterschiedlichen Zeitpunkten ihren Zustand ändern.
Das Modul KY-040 verfügt über zwei Pull-Up-Widerstände für den Encoder.
Zusätzlich besitzt der Drehknopf eine unabhängige Tasterfunktion (S1), die durch Niederdrücken der Drehachse ausgelöst wird.
An diesem Taster ist kein Pull-Up-/Pull-Down-Widerstand angeschlossen, obwohl er auf der Platine vorgesehen ist.




BlackBoard Circuit Designer Schaltplan



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






Drehgeber-Modul / Encoder
Durch Drehen des Drehgebers kann im Gegensatz zum Drehpotentiometerzähler in der positiven und in der umgekehrten Richtung bei der Drehung der Ausgangsimpulsfrequenz gezählt werden, wobei die Artenrotationszählungen nicht begrenzt sind.
Mit den Tasten am Drehgeber kann auf den Anfangszustand zurückgesetzt werden, der von 0 beginnt.

Funktionsweise:
Inkrementalgeber ist eine Verschiebung des Drehimpulssignals wird in eine Serie von digitalen Drehsensoren umgewandelt.

Diese Impulse werden zur Steuerung der Winkelverschiebung verwendet.

In Eltra Winkelverschiebungs-Encoder-Umwandlung unter Verwendung eines photoelektrischen Abtastprinzips.

Das Lesesystem des abwechselnden lichtdurchlässigen Fensters und des Fensters besteht nicht aus einer Rotationsbasis der radialen Indexierungsplatte (Codierrad),
während es ein Infrarotlichtquellen-Vertikal-Bestrahlungslicht zu dem Codescheibenbild auf dem Empfang ist

An der Oberfläche.
Der Empfänger ist mit einem Beugungsgitter abgedeckt, das die gleiche Fensterbreite hat.

Die Aufgabe des Empfängers besteht darin, die Rotation der Scheibe zu fühlen.
Resultierende Änderungen und ändern das Licht in entsprechende elektrische Änderungen.

Dann die Low-Pegel-Signale bis zu einem höheren Niveau, und erzeugt keine Interferenz Square Puls, die von elektronischen Schaltungen verarbeitet werden muß.

Lesesysteme verwenden typischerweise eine differentielle Art und Weise, etwa die gleiche, aber die Phasendifferenz der beiden Wellenformen,
die um 180 ° gegenüber dem Signal verschieden sind, um die Qualität und Stabilität des Ausgangssignals zu verbessern.

Lesen ist dann die Differenz zwischen den beiden Signalen auf der Grundlage gebildet, also die Beseitigung der Interferenz.

Inkrementalgeber

Inkrementale Drehgeber geben zwei-Phasen-Rechteck, die Phasendifferenz zwischen ihnen 90 °, oft als A-und B-Kanäle bezeichnet.
Einer der Kanäle ist gegeben und Geschwindigkeitsbezogenen Informationen, zur gleichen Zeit, durch sequentielles Vergleichen von zwei Kanalsignalen, die Richtung der Drehung der erhaltenen Informationen.

Es gibt auch ein spezielles Signal Z oder Zero-Kanal, die den absoluten Nullpunkt-Encoder gibt, ist das Signal eine Rechteckwelle mit der Mittellinie des Kanals Eine Rechteckwelle zusammenfallen.

CW = Im Uhrzeigersinn     CCW = gegen den Uhrzeigersinn
A B
1 1
0 1
0 0
1 0
1 1
1 0
0 0
0 1


Inkrementalgeber Genauigkeit hängt von den mechanischen und elektrischen zwei Faktoren, diese Faktoren sind:
Rasterindizierung Fehler, Exzentrizität der Exzenter, Lager Exzentrizität, E-Lesen Mehrere Mittel in den optischen Teil der Fehler und Ungenauigkeiten.

Ermitteln Sie, dass die Encoderauflösung in elektrischen Graden gemessen wird, die Gebergenauigkeit ist abhängig davon, dass der Impulsgeber eine Indexierung erzeugt.

Die folgenden elektrischen Grade mit einer 360º-Drehung der Welle zu der Maschine und die Drehung der Welle müssen eine volle Woche des Zeitraums sein.

Um zu wissen, wieviel elektrisches Äquivalent des mechanischen Winkels von 360 Grad mit der folgenden Formel berechnet werden kann:
Elektrisch 360 = Maschine 360 ​​° / n ° Impulse / Umdrehung

Abbildung: A, B Kommutierungssignale
Encoder Indexing-Fehler ist der elektrische Winkel der Einheit zwei aufeinander folgende Puls-Maximum-Offset zu vertreten.
Fehler in jedem Encoder, der durch die oben genannten Faktoren verursacht wird.

Eltra Encoder maximale Fehler ist ± 25 elektrische Grad (in jedem Zustand deklariert), entspricht der Nenn-Offset-Werte ± 7%,
da die Phasendifferenz 90 ° (elektrisch) der beiden Kanäle der maximalen Abweichung ± 35 elektrische Grad gleich ist
± 10% Abweichung links.

UVW Inkrementalgeber-Signale Neben dem konventionellen Geber gibt es noch ein weiteres elektrisches Ausgangssignal mit integriertem Inkrementalgeber.
Und UVW-Signale Die integrierte Inkrementalgeber, dass Instanz, es ist in der Regel auf die AC-Servomotor Feedback.

Diese magnetischen Signale erscheinen in der AC-Servomotor Maschine, UVW durch die Simulation des magnetischen Signals ist in der Regel von der ursprünglichen Funktion und Design.

Im Eltra-Codierer sind diese optischen Signale UVW-Verfahren und drei Rechteckwellenformen voneinander um 120 ° versetzt.

Um das Starten des Motors zu erleichtern, muss die Steuerung des Startermotors auf diese das richtige Signal sein.

Die UVW-Pole in den Maschinenachsendrehimpulsen werden oft wiederholt, da sie direkt von der angeschlossenen elektrischen Maschinenzahl der Pole und von 6 oder mehr Pol-Motor-UVW-Signalen abhängen.

Siehe auch
Youtube video

Beispielcode für ARDUINO UNO
Sketch KY-040

// Rotary encoder module
int redPin = 2;
int yellowPin = 3;
int greenPin = 4;
int aPin = 6;
int bPin = 7;
int buttonPin = 5;
int state = 0;
int longPeriod = 5000; // Time at green or red
int shortPeriod = 700; // Time period when changing
int targetCount = shortPeriod;
int count = 0;
void setup ()
{
  pinMode (aPin, INPUT);
  pinMode (bPin, INPUT);
  pinMode (buttonPin, INPUT);
  pinMode (redPin, OUTPUT);
  pinMode (yellowPin, OUTPUT);
  pinMode (greenPin, OUTPUT);
}
void loop ()
{
  count++;
  if (digitalRead (buttonPin))
  {
    setLights (HIGH, HIGH, HIGH);
  }
  else
  {
    int change = getEncoderTurn ();
    int newPeriod = longPeriod + (change * 1000);
    if (newPeriod  >= 1000 && newPeriod <= 10000)
    {
      longPeriod = newPeriod;
    }
    if (count> targetCount)
    {
      setState ();
      count = 0;
    }
  }
  delay (1);
}
int getEncoderTurn ()
{
  // Return -1, 0, or +1
  static int oldA = LOW;
  static int oldB = LOW;
  int result = 0;
  int newA = digitalRead (aPin);
  int newB = digitalRead (bPin);
  if (newA != oldA || newB != oldB)
  {
    //Something has changed
    if (oldA == LOW && newA == HIGH)
    {
      result = - (oldB * 2 - 1);
    }
  }
  oldA = newA;
  oldB = newB;
  return result;
}
int setState ()
{
  if (state == 0)
  {
    setLights (HIGH, LOW, LOW);
    targetCount = longPeriod;
    state = 1;
  }
  else if (state == 1)
  {
    setLights (HIGH, HIGH, LOW);
    targetCount = shortPeriod;
    state = 2;
  }
  else if (state == 2)
  {
    setLights (LOW, LOW, HIGH);
    targetCount = longPeriod;
    state = 3;
  }
  else if (state == 3)
  {
    setLights (LOW, HIGH, LOW);
    targetCount = shortPeriod;
    state = 0;
  }
}
void setLights (int red, int yellow, int green)
{
  digitalWrite (redPin, red);
  digitalWrite (yellowPin, yellow);
  digitalWrite (greenPin, green);
}

Quelle:
https://tkkrlab.nl/wiki/Arduino_37_sensors
https://tkkrlab.nl/wiki/Arduino_KY-040_Rotary_encoder_module
http://www.instructables.com/id/Arduino-Rotary-Encoder-Simple-Example-KY-040/




ALLNET 4duino Sensor Kit Experimentierkasten
37-in.1 Sensoren / Module  Art.-Nr. 111861
www.allnet.de
Kurz-Beschreibung
715_d_ARDUINO-x_ALLNET Arduino 37-in-1 Sensor Kit - Experimentierkasten (7 Seiten)_1a.pdf


KY-040 Kodierter Drehschalter (Rotary Encoder)


Codebeispiel Arduino

Das Programm überprüft, falls eine Änderung der Pin-Zustände sich ereignet hat, welcher der beiden Pins sich zuerst geändert hatte, was auf die Drehrichtung schließen lässt.
Diese Information erhält man, in dem man einen der beiden Pin-Werte aus einem vorherigen Durchlauf mit dem Wert des aktuellen Durchlaufs vergleicht.
Nachdem die Richtung festgestellt wurde, werden die Schritte von der Startposition an gezählt und ausgegeben.
Ein Drücken auf den Knopf des Drehgebers resettet die aktuelle Position.

Für die serielle Ausgabe: Baudrate= 115200


// Initialisierung benötigter Variablen
int Counter = 0;
boolean Richtung;
int Pin_clk_Letzter; 
int Pin_clk_Aktuell;
 
// Definition der Eingangs-Pins
int pin_clk = 3; 
int pin_dt = 4;
int button_pin = 5;
  
  
void setup()
{
   // Eingangs-Pins werden initialisiert...
   pinMode (pin_clk,INPUT);
   pinMode (pin_dt,INPUT);
   pinMode (button_pin,INPUT);
    
   // ...und deren Pull-Up Widerstände aktiviert
   digitalWrite(pin_clk, true);
   digitalWrite(pin_dt, true);
   digitalWrite(button_pin, true);
    
   // Initiales Auslesen des Pin_CLK
   Pin_clk_Letzter = digitalRead(pin_clk);  
   Serial.begin (115200);
 }
 
// Das Programm überprüft, falls eine Änderung der Pin-Zustände sich ereignet hat, welcher der beiden
// Pins sich zuerst geändert hatte, was auf die Drehrichtung schließen lässt.
// Diese Information erhält man, in dem man einen der beiden Pin-Werte aus einem vorherigen
// Durchlauf mit dem Wert des aktuellen Durchlaufs vergleicht.
// Nachdem die Richtung festgestellt wurde, werden die Schritte von der Startposition an gezählt und ausgegeben.
// Ein Drücken auf den Knopf des Drehgebers resettet die aktuelle Position.
 
void loop()
{
   // Auslesen des aktuellen Statuses 
   Pin_clk_Aktuell = digitalRead(pin_clk);
    
   // Überprüfung auf Änderung
   if (Pin_clk_Aktuell != Pin_clk_Letzter)
   {
          
        if (digitalRead(pin_dt) != Pin_clk_Aktuell)
        
            // Pin_CLK hat sich zuerst verändert
            Counter ++;
            Richtung = true;
        }
          
        else
        {       // Andernfalls hat sich Pin_DT zuerst verändert
            Richtung = false;
            Counter--;
        }
        Serial.println ("Drehung erkannt: ");
        Serial.print ("Drehrichtung: ");
         
        if (Richtung)
        {
           Serial.println ("Im Uhrzeigersinn");
        }
        else
        {
           Serial.println("Gegen den Uhrzeigersinn");
        }
         
        Serial.print("Aktuelle Position: ");
        Serial.println(Counter);
        Serial.println("------------------------------");
          
   }
    
   // Vorbereitung für den nächsten Druchlauf:
   // Der Wert des aktuellen Durchlaufs ist beim nächsten Druchlauf der vorherige Wert
   Pin_clk_Letzter = Pin_clk_Aktuell;
    
   // Reset-Funktion um aktuelle Position zu speichern
   if (!digitalRead(button_pin) && Counter!=0)
     {
       Counter = 0;
       Serial.println("Position resettet");
     }
      
 }


KY-040_RotaryEncoder.zip

http://www.linkerkit.de/index.php?title=KY-040_Kodierter_Drehschalter_(Rotary_Encoder)


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--040  Rotary Encoder

Rotary Encoder

In diesem Post geht es darum, wie man einen Rotary Encoder mit dem Arduino verwendet. Rotary Encoder sind, ähnlich wie Potentiometer, Bauteile welche einen "Drehknüppel" haben. Der wesentliche Unterschied zwischen einem Potentiometer und einem Rotary Encoder ist jedoch, dass man einen Rotary Encoder in beide Richtungen unendlich weit drehen kann.


Die Funktionsweise eines Rotary Encoders

Ich besitze den Keyes KY 040 Rotary Encoder, welchen man für ca. 1 Euro kaufen kann. Dieser Rotary Encoder hat fünf Pins. Der GND Pin muss mit dem Ground verbunden werden, und der + Pin mit den 5V des Arduino. Über den SW Pin kann man auslesen, ob der, in den Knüppel integrierte, Button gedrückt wird oder nicht. Dieser wird mit einem digitalen Pin des Arduino verbunden. 

Auch der DT und der CLK Pin müssen mit einem digital Pin des Arduino verbunden werden. Dabei sind die beiden Pins normalerweise auf HIGH geschaltet. Sobald man jedoch anfängt den Knüppel in eine Richtung zu drehen, so werden die beiden Pins auf LOW geschaltet. 

Dabei ist jedoch die Reihenfolge entscheidend. Wird erst der eine Pin LOW, so wird der Knüppel in Richtung A gedreht, wird erst der andere Pin LOW, wird der Knüppel in Richtung B gedreht. Da an dieser Stelle das Programm sehr schnell reagieren muss, sollte man die Überprüfung in einen Interrupt machen. Hier ist ausführlich erklärt, wie man Interrupts mit dem Arduino verwendet.

Arduino Sketch zum Auslesen

Zunächst einmal muss man die beiden belegten digital Pins als INPUT definieren(der eine muss Pin 2 sein, da wir einen Interrupt verwenden). Außerdem muss der Interrupt definiert werden. In der Interruptroutine werden die Zustände der Pins geprüft und die Richtung ermittelt, und im loop Teil die Werte ausgewertet.

In diesem Beispielsketch wird die LED des Arduino(Pin 13) entsprechend dem Rotary Encoder gedimmt.



#include <SoftPWM.h>
#include <SoftPWM_timer.h>

int status_pin = 1;
int richtung = 1;
boolean bewegung = false;
int counter = 0;

void setup() {
pinMode(2, INPUT);
pinMode(3, INPUT);
Serial.begin(9600);
attachInterrupt(0, motion, FALLING); //definieren eines Interrupts an Interruptpin 0 (Arduino Pin 2)
SoftPWMBegin();
SoftPWMSet(13, 0); //LED des Arduino zum Zeigen der aktuellen Werte

}

void loop() {
if(bewegung) {
if(richtung)
{
counter = counter + 1;
}
else {
counter = counter -1;
}
SoftPWMSet(13, counter);
Serial.println(counter);
} //auslesen der Werte und hoch-/runterzaehlen
bewegung = false;

}

void motion() {
status_pin = digitalRead(2);
if(status_pin == digitalRead(3)) //wenn status gleich(beide low), dann pin 3 zuerste, also richtung 1, wenn unterschiedlich pin 2 zuerst, also richtung 0
{
richtung = 1;
}
else {
richtung = 0;
}
bewegung = true;
}






*********************************************************

Beschreibung:
Arduino ist eine vielseitige Plattform, die einfach zu programmieren und einfache, komplexe Aufgaben mit Hilfe von Open-Source-Bibliotheken zu tun.
Arduino-Board kommt mit keinerlei Sensoren, dieses Kitset überbrückt die Lücke und erlaubt dem  scharfen Arduino-Experimentator Zugang zu einem Reihe von Sensoren und Steuerungen, um viele große Projekte zu bauen.
Ein häufig vorkommendes Problem mit Schnittstellenhardware zu Arduino ist Mangel an leicht verfügbaren Beispielen, um es zu erhalten,
Wir stellen eine komplette Bibliothek (auf Kauf) für zur Verfügung
Alle Sensoren, um es einfach für den Benutzer, um sie gehen und gehen auf den Bau von interessanten Projekten, anstatt zu kämpfen, um die richtige Bibliothek für jeden Sensor zu finden.
Dies wäre ein ideales Geschenk für jeden Tinkerer, die gerne mit Elektronik und Programmierung spielen.
Dieses Kit würde Stunden von Aufregung, Experimentieren und bieten Lernen und ein Sprungbrett, um weiter zu bewegen, um größere Dinge zu bauen und Probleme zu lösen.
Dieses vielseitige Kit für den Arduino kommt mit 30+ Sensoren, die für die Durchführung einer Vielzahl von Experimenten verwendet werden kann.
Sie haben einfach zu bedienen Anschlüsse, die Anbindung an die Arduino Geradeaus macht.
Dieses Kit kommt mit einem ARDUINO UNO TR3 kompatiblen Board zusammen mit allen unten aufgeführten Sensoren:







*********************************************************
       37-in-1 Sensors kit for Arduino - Module

   SPALTE-1

KY-023  JoyStickDer analoge Joystick verfügt über zwei Achsen und 2x 10k Potentiometer mit Tastendruck.
Steckerstifte sind auf der Platine beschrieben.
Im Lieferumfang des Moduls befindet sich ein Druckknopf.



KY-019  Relay Dieses einzelne Relaismodul kann direkt an ein Arduino angeschlossen werden und benötigt eine 5Vdc Versorgung für den Betrieb.
Die Eingabe ist mit einem 'S' gekennzeichnet.

Das Relais verfügt über einen Wechsler und kann Widerstände bis zu 10A bei 250Vac und bis zu 10A bei maximal 30Vdc schalten.

Eine Entstörung ist erforderlich.



KY-037  Big sound / Sensitive Microphone Dieses verfügt über eine hochempfindliche großformatige Elektretkapsel und ein Potentiometer, das die Einstellung des Schallpegels ermöglicht.
Der Ausgang D0 (aktiv hoch) wird umgeschaltet, wenn der Schallpegel einen vorgegebenen Wert überschreitet.

Der Analogausgang steht an Pin A0 zur Verfügung.



KY-038  Small sound / Small Microphone Abgesehen von der kleineren Kapselgröße und der geringeren Empfindlichkeit ist dieses Modul identisch mit dem oben beschriebenen empfindlichen Mikrofon.


KY-032  Tracking / IR Light Reflection Switch  zum schwarze Linie abtasten Dieser Schalter ist nützlich, um Hindernisse zu vermeiden oder ein Modell zu erhalten, das sich nach einer Linie um den Boden bewegt.
Ein Hindernis vor den Sender- / Empfangsdioden bewirkt, dass der Ausgangsbolzen niedrig gezogen wird (aktiv niedrig).

Der Erfassungsbereich beträgt ca. 1cm und ein Potentiometer ermöglicht die Einstellung der Empfindlichkeit.



KY-033  Avoid / IR Reflection Sensor  Entfernungs-Sensor Auch für Anwendungen geeignet, wo Hindernisse vermieden werden müssen.
Wenn ein Hindernis von dieser Einheit erkannt wird, wird der Ausgangspin niedrig (aktiv niedrig).

Dies hat eine verbesserte Entfernungsempfindlichkeit, da sie Objekte bis zu etwa 7cm erkennen kann, wobei die Empfindlichkeit über ein Potentiometer einstellbar ist.

Um einen kontinuierlichen Betrieb zu ermöglichen, kann ein Jumper (EN) installiert werden.

Wenn der Jumper nicht vorhanden ist, kann ein externes Logiksignal an die Brücke gelegt werden, um den Detektor ein- und auszuschalten.

Dies ist aktiv niedrig.







   SPALTE-2

KY-026  FlameMit einem typischen Spektralempfindlichkeitsbereich von 720..1100nm bei einem Winkel von 60 Grad ermöglicht dieses Modul
die Detektion von Flammen und ist so optimiert, dass Emissionen von offenen Flammen erfasst werden.

Wenn eine Flamme erkannt wird, geht DO hoch (aktiv hoch).

Die Erfassungsschwelle kann mit dem Potentiometer eingestellt werden.

Das analoge Ausgangssignal ist über pin-A0 zugänglich.



KY-024  Linear Hall Dies erkennt das Vorhandensein eines Magnetfeldes.
Wenn ein solches Feld vorhanden ist, geht DO hoch (aktiv hoch).

Der Punkt, an dem dies geschieht, hängt von Faktoren wie Feldstärke, Polarität und der Position des Magneten relativ zum Sensor und der Empfindlichkeitseinstellung des Potentiometers ab.

Das analoge Ausgangssignal steht am pin-A0 zur Verfügung.



KY-036  Touch / Sensitive Switch Das Berühren des Sensorstifts erzeugt einen Ausgang bei DO und ist aktiv hoch.
Der Ausgang enthält 50Hz Netzsignale, so dass es nicht sauber ist.

Die Empfindlichkeit kann mit einem Potentiometer eingestellt werden und das analoge Ausgangssignal steht an pin-A0 zur Verfügung.



KY-028  Digital temp / Digital Temperature Sensor Dieser Temperatursensor verwendet einen NTC-Thermistor.
Ein Potentiometer erlaubt die Einstellung einer Temperaturschwelle, die bewirkt, dass Pin-D0 bei Erreichen dieser Temperatur hoch schaltet.

Der analoge Ausgang des Sensors ist auf pin-A0 zugänglich.



KY-012  buzzer / Aktive Buzzer Es ist alles im Namen wirklich, dieses Modul ist ein elektronischer Summer.
Achten Sie beim Anschließen darauf, dass 5Vdc auf dem '-' - Stift montiert werden muss, während der Boden auf dem mit 'S' markierten Stift steht.

Es arbeitet typischerweise mit einer Frequenz von 4kHz bei einem Minimum von 80dB und zieht typischerweise 5mA bei 5Vdc.
Dieser Buzzer sieht dem passiven Buzzer sehr ähnlich, kann aber identifiziert werden, da der Summer selbst etwas größer ist als die passive Version.



KY-006  Passive buzzer Dieser Summer oder Mini-Lautsprecher ist etwas kürzer als der Summer oben.
Es hat 16 Ohm Impedanz und maximale Dauerstrom durch die Lautsprecher-Spule beträgt etwa 25mA.

Die äußeren zwei Stifte '-' und 'S' verbinden sich mit dem Lautsprecher und sind nicht polaritätsempfindlich.







   SPALTE-3

KY-016  RGB LED Diese klare Linsenfarbe LED verwendet einen 150 Ohm Reihenwiderstand und kann auf 5Vdc verwendet werden.
Die '-' ist die gemeinsame Kathode, aber wir wissen, dass die Beschriftung auf der Platine falsch ist.

Rot und Blau sind eigentlich umgekehrt.



KY-009  SMD RGB / LED Es gibt keinen Reihenwiderstand, der mit dieser RGB-LED geliefert wird, also müssen Sie Ihre Selbst zur Verfügung stellen.
Ein 220 Ohm Widerstand wäre geeignet.
Der '-' - Pin kennzeichnet eine gemeinsame Kathode, aber wie zuvor ist die Leiterplattenbeschriftung nicht korrekt.

Dieses Mal werden jedoch die grünen und roten Anschlüsse umgeschaltet.


KY-011  Two-color / Bi-colour 5mm LED Mit dieser zweifarbigen LED repräsentiert '-' die gemeinsame Kathode auf der Platine.
Der mit 'R' gekennzeichnete Stift ist für die Rote Anode und der 'S' Pin für die Grüne Anode.

Da es keinen Reihenwiderstand gibt, müssen Sie eine, ungefähr 220Ohm zur Verfügung stellen.



KY-029  Two-color / Bi-colour 3mm LED Wie die 5mm LED oben zeigt das '-' auf der Platine die gemeinsame Kathode an.
Der mittlere Pin ist die Anode für die rote LED und der 'S' Pin für die grüne LED.

Da es keinen Reihenwiderstand gibt, müssen Sie eine, ungefähr 220Ohm zur Verfügung stellen.



KY-025  Reed switch  braucht keiner einen Reed-Kontakt kann man nicht analog auslesen Neben einem digitalen Ausgang auf D0 bietet dieser Reed-Schalter auch einen Analogausgang auf A0.
Ground kann bei der 'G' Pin gefunden werden, während '+' 5Vdc benötigt.

Das mitgelieferte Potentiometer wird als Pull-up-Widerstand verwendet.



KY-021  Mini Reed / switch braucht keiner ein Reed-Kontakt funktioniert auch ohne Leiterplatte Die äußeren zwei Pins des 3-poligen Steckers verbinden sich mit dem Reed-Schalter.
Es ist normalerweise offen und erfordert ein Magnetfeld, um die Kontakte zu schließen.

Ein 10k Ohm Widerstand ist an Bord und ist zwischen dem Mittelstift und dem 'S' Stift angeschlossen.

Dies kann als Pull-Up oder Pull-Down-Widerstand verwendet werden.







   SPALTE-4

KY-039  HeartbeatHerzschlag-Sensor
Diese ordentliche Vorrichtung kann verwendet werden, um den Puls einer Person zu lesen, wenn eine Fingerspitze zwischen der Infrarot-LED und dem Phototransistor angeordnet ist.
Externe Schaltkreise werden benötigt.
5Vdc muss mit dem Mittelpin versorgt werden, die Masse ist mit dem Pin '-' verbunden
und das Phototransistorsignal steht am S-Pin zur Verfügung (dieser besitzt einen eigenen Pull-up-Widerstand).

Ein 300ohm Widerstand für die Infrarot-LED ist enthalten.



KY-034  7 colour Flashing / LED 7 Farbe Blinkende LED
Diese klare Linsen-LED läuft direkt von 5Vdc und schaltet automatisch durch eine siebenfarbige Sequenz.
5Vdc muss mit dem 'S' Pin und Masse auf dem zentralen Pin verbunden werden.



KY-008  Laser emitter Das Lasermodul hat eine Wellenlänge von 650nm im roten Farbspektrum.
5Vdc können direkt an den 'S' Pin und Masse an den '-' Pin angeschlossen werden.



KY-004  Button / Push Button Switch  braucht keiner ein Mini-Taster werden direkt in das BreadBoard gesteckt Ein 10k-Ohm-Widerstand verbindet den mittleren Pin und den mit 'S' bezeichneten Pin und kann als Pull-Down- oder Pull-Up-Widerstand verwendet werden.
Die beiden äußeren Stifte sind mit dem Druckknopf verbunden.

Es gibt verschiedene Tastenbibliotheken für den Arduino, die mit diesem Modul verwendet werden können.
.


KY-002  Shock / Rolling Ball Type Tilt Switch  Modul braucht keiner es genügt der SchalterSchock, rollender Kugel-Art Neigung-Schalter
Die Schaltkontakte sind an den beiden äußeren Stiften 'S' und '-' verfügbar.
Ein 10k Ohm Widerstand verbindet die Mitte und 'S' Stifte und kann als Pull-Down oder Pull-up-Widerstand verwendet werden.



KY-040  Rotary encoder  Modul braucht keiner es genügt der Encoder Drehcodierer
Dieser Encoder ist für die Herstellung eines elektronischen Potentiometers geeignet.
Pin-Markierungen befinden sich auf der Platine.







   SPALTE-5

KY-027  Light Cup / 2x Als Paar liefern diese Module einen Quecksilber-Kippschalter und transparente rote LEDs.
Die LED-Kathode und ein Anschluss des Schalters stehen am 'G'-Pin zur Verfügung.

Die andere Seite des Schalters steht am 'S'-Pin zur Verfügung und' L 'verbindet sich mit der LED-Anode (ein Serienwiderstand ist nicht vorgesehen, so dass ein 220 Ohm Widerstand angeschlossen werden muss).

Der '+' Pin ist mit einem 10k Ohm Pull up Resider verbunden, der mit dem 'S' Pin des Switches verbunden ist.



KY-017  Tilt switch     Modul braucht keiner es genügt der Schalter Abhängig von der Höhe, in der dieser Sensor positioniert ist, wird der Quecksilberneigungsschalter eine Verbindung herstellen oder brechen.


KY-020  Ball switch / Rolling Ball / Tilt Switch  Modul braucht keiner es genügt der Schalter Ball Kippschalter
Abhängig von Ihrer Anwendung kann der eingebaute 10k Ohm Widerstand, der zwischen den mittleren und 'S' Stiften angeschlossen wird, für Pull-Down oder Pull-up verwendet werden.
Die äußeren zwei Pins sind für die Schaltkontakte, die eine maximale Schaltlast von 50mA bei 12VDC haben.



KY-018  Photoresistor  Modul braucht keiner es genügt der LDR Der Photoresistor, auch bekannt als ein Lichtabhängiger Widerstand (LDR05), bestimmt Dunkelheit, wenn der Widerstand über 20M Ohm ist, und Licht mit weniger als 80 Ohm.
Die beiden äußeren Stifte sind zu verwenden.

Zwischen dem mittleren und dem S-Pin befindet sich ein 10k Ohm-Widerstand am Modul, was den Aufbau einer Messbrückenschaltung vereinfacht.



KY-015  Temperature and humidity  Modul braucht keiner es genügt der Sensor Temperatur und Luftfeuchtigkeit
Der beliebte DHT11 Sensor ermöglicht das Lesen von Temperatur und Feuchtigkeit.
Es kann Temperatur im Bereich 0..50 Grad Celsius (+/- 2%) und relative Luftfeuchtigkeit in den 20..95% (+/- 5%) erkennen.

Es arbeitet mit einer Versorgungsspannung von 3Vdc bis 5,5Vdc und verfügt über einen eingebauten 10k Ohm Pull-up-Widerstand.

Für die Verwendung mit der Arduino DHT.h Bibliothek.



KY-035  Analog Hall / Sensor Switch  Modul braucht keiner es genügt der SensorAnaloger Hall-Sensor-Schalter
Dieses Modul verfügt über einen Sensor 44E311, 3144EUA-S, 3144LUA-S oder 49E504BG mit LED und Widerstand.
Wird ein Magnetfeld erkannt, leuchtet die LED.
Ground wird durch ein '-' auf der Platine, Signal auf dem 'S' Pin und 5VDC auf dem Center Pin angezeigt.







   SPALTE-6

KY-003  Hall Magnetic  Modul braucht keiner es genügt der Sensor Ein Halleffektsensormodul mit einem analogen Ausgangssignal.
Der Ausgang steht auf dem mit 'S' bezeichneten Pin zur Verfügung, der auf dem mit '-' gekennzeichneten Pin liegt.



KY-001  Temperature Temperatursensor
Der DS18B20 ist ein eindrahtiger digitaler Temperatursensor mit einem Bereich von -55 bis +125 Grad Celsius.
Je nach Programm hat es eine Auflösung von 9 .. 12 bits mit einer Genauigkeit von 0,5 Grad Celsius.

Ein 4,7k Ohm Widerstand ist auf der Busleitung enthalten.

Zusätzliche Sensoren können dem Bus hinzugefügt und individuell adressiert werden.

Es sollte nur ein Pull-up-Widerstand an den Bus angeschlossen werden, unabhängig davon, wie viele Sensoren dieser Art zusammen verwendet werden.



KY-013  Analog Temperature  Modul braucht keiner es genügt der 4,7k NTC Analoger Temperatursensor
Ein NTC-Temperatursensor. Der Sensorwiderstand beträgt bei Raumtemperatur ca. 10k Ohm und der Ausgang über die beiden äußeren Pins zugänglich.
Ein fester Widerstand 10k Ohm, der zwischen den mittleren und 'S' Stiften angeschlossen wird, ist enthalten, was den Aufbau einer Messbrückenschaltung vereinfacht.

Wie der digitale Sensor DS18B20 oben, teilt es den gleichen Temperaturbereich und Genauigkeit.



KY-005  IR emission / IR Emitter / IR-Sender Wenn Sie eine eigene IR-Fernbedienung erstellen möchten, dann finden Sie diesen Emitter nützlich.
Ground ist an der '-' Pin, 'S' ist die Daten in während der mittlere Pin ist 5Vdc liefern.



KY-022  IR receiver / IR-Empfänger IR Empfänger
Dieser Sensor ist der Typ 1838 und dient zur Verwendung mit 38kHz-IR-Signalen.
Es arbeitet auf einer Versorgungsspannung von 2,7V bis 5,5V, 37,9kHz Frequenz, mit einem typischen Bereich von 18m und einem Empfangswinkel von 90 Grad.

Eine nützliche Bibliothek dazu finden Sie unter https://github.com/shirriff/Arduino-IRremote.
https://github.com/shirriff/Arduino-IRremote.


KY-031  Tap module  Modul braucht keiner es genügt der Schalter Vibrations-Modul
Dieses Modul erkennt Vibrationen.
Die Schaltkontakte sind an den äußeren beiden Stiften vorhanden.



KY-010  Light blocking  Modul braucht keiner es genügt die Gabellichtschranke Lichtsperrsensor
Eine geschlitzte Lichtschranke.

Der mittlere Pin benötigt + 5Vdc Versorgung und Masse steht bei '-' zur Verfügung, das Ausgangssignal steht auf dem verbleibenden Pin zur Verfügung
und verfügt über einen 10k Ohm Widerstand, der an + 5Vdc angeschlossen ist.




Quelle:
http://www.hobbyist.co.nz/?q=arduino-sensor-kit








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

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






  
Comments