KY-021..030

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

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
*********************************************************
9 Untergeordnete Seiten:
ArduinoSensor

ArduinoSensors

Documenta

  KY-001..010

    KY-011..020

      KY-021..030
         KY-031..040
           KY-050..KY-055

              Pin-Belegung


715_d_ARDUINO-x_ALLNET Arduino 37-in-1 Sensor Kit +++ Beschreibung (12 Seiten)_1a.pdf
715_d_ARDUINO-x_37-in-1 Sensor kit  for Arduino +++ Beschreibung (51 Seiten)_1a.pdf
715_d_ARDUINO-x_jOY-iT Arduino 37-in-1 Sensor Kit X40 +++ Beschreibung (227 Seiten)_1a.pdf
http://sensorkit.joy-it.net/

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




3.19   KY-021 - Reedschalter
Arduino KY-021
Kleines Reed-Schalter Modul - Mini Reed

Mini magnetic reed modules for Arduino KY-021
Arduino - Magnetic Reed Switch KY-021

Reedkontakt 2mm x 13mm
Miniatur Reed Kontakt
Reedschalter Schließer



Standard Miniatur Reedschalter mit Schließerfunktion.
Strom:          max. 500mA
Spannung : max. 200V AC/DC
Leistung:     max. 10W
Kontakt:       Schließer
Abmessungen: Länge 13mm / Durchmesser 2mm



ODER  siehe AUCH weiter UNTEN   Arduino KY-025 Reed-Schalter Modul - Reed switch


Ein Reedschalter besteht aus zwei in einem Glasrohr eingeschmolzenen Kontaktzungen und wird magnetisch betätigt, wodurch der Stromkreis geschlossen wird.
Wichtig ist, daß das Magnetfeld zum Schalten axial (parallel zum Gehäuse) ausgerichtet ist, also der magnetische Nord- und Südpol jeweils zu einem Ende des Bauteils zeigen.
Die Stärke des benötigten Magnetfeldes hängt von dem Bauteiltyp ab, ist aber in der Regel relativ gering.
Die magnetischen Schaltzungen sind nur wenige Mikrometer (zehn tausenstel mm) voneinander entfernt, so dass der Schaltvorgang nicht oder kaum hör- oder sichtbar ist.
Reedschalter können (je nach Typ) hohe Spannungen und Ströme bis ca. 5 Amp.  schalten.
Sie arbeiten in einem großen Temperaturbereich und auch unter rauen Bedingungen, da sie im Hinblick auf Feuchtigkeit, Öle usw. ebenso unempindlich sind, wie hinsichtlich niederfrequenter Vibrationen.
Der vorhandene 10k Widerstand kann als Pull-Up oder Pull-Down verwendet werden.




Pinbelegung bei meinem Modul ist aber so.


Pin  - = GND
Pin Vcc = +5,0V

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

BlackBoard Circuit Designer Schaltplan
KY-021 bis KY-030 Schaltungen_1b.bbs



Mini reed switch module

Mini Reed-Kontakt, verbindet die beiden äußeren Pins der Platine.
Ohne Magnetfeld ist der Kontakt offen.
Eingebauter 10kOhm Widerstand als Pull-up oder Pull-down zwischen dem mittleren und dem „S“-Anschluss (Output).

Mini Reedschaltermodul
Ein Reedmodul ist ein magnetischer Sensor, der normalerweise offen ist und geschlossen wird, wenn er einem Magnetfeld ausgesetzt wird.
Schalten Sie in unserem Beispiel die Build-LED auf pin-13 bei geschlossenem Sensor aus.
Dazu muss ein Magnet in der Nähe des Reed-Schalters gehalten werden.


Das Modul enthält einen 10k Ohm Widerstand, so dass kein zusätzlicher Spannungs-Teiler benötigt werden.

Schema

     Arduino GND               zu    Modul Pin -                           Ground
     Arduino +5V                zu    Modul Pin + (mittlerer-Stift)  Power
     Arduino Digital pin-3   zu    Modul S                                Output

Beispielcode für ARDUINO UNO
Sketch KY-021

//
// Example code for sensor KY021
// More info on http://tkkrlab.nl/wiki/Arduino_KY-021_Mini_magnetic_reed_modules
//
int Led = 13 ;      // Eingebaute smd-LED
int buttonpin = 2;  // Reed-Sensor pin-2
int val ;           // define numeric variables val
void setup ()
{
  pinMode (Led, OUTPUT) ;       // define smd-LED as output interface
  pinMode (buttonpin, INPUT) ;  // output interface as defined Reed sensor
}
void loop ()
{
  val = digitalRead (buttonpin) ; // digital interface will be assigned a value of pin-2 to read val
  if (val == HIGH)                // When the Reed sensor detects a signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}
https://tkkrlab.nl/wiki/Arduino_KY-021_Mini_magnetic_reed_modules
http://www.instructables.com/id/Arduino-Reed-Switch/
http://www.instructables.com/id/Arduino-Magnetic-Reed-Switch-KY-021/
https://www.hackster.io/vandenbrande/arduino-magnetic-reed-switch-ky-021-40c282
http://www.arduino-tutorial.de/2010/08/reed-schalter/
https://www.sparkfun.com/products/8642
https://www.adafruit.com/product/375
http://www.dx.com/de/p/reed-switch-sensor-module-for-arduino-blue-150795#.WEJpqVzPj7I






Liste der Einzelteile:
Arduino Uno R3
KY-021 Mini-Reed-Schalter
KY-019 1-Kanal Relais.
Permanent-Magnet


//  Verfasser: Danny van den Brande, www.arduinosensors.nl
// Hallo Welt! Ich habe ein einfaches Beispiel auf der KY-021 Mini Reed-Schalter / Arduino Magnetic Reed Switch.
// Tun Sie, was immer Sie mit diesem Code mögen! Dieser Code schaltet ein Relais ein.
// In meinem Video habe ich eine Lampe, aber Sie können jedes Gerät, um das Relais hinzufügen, wenn Sie wollen.
// Reed-Schalter können für ein Dutzend Dinge verwendet werden, ist aber vor allem für seine Verwendung bekannt
// in Alarmanlagen und arbeiten mit einem Magnetfeld.

int Relay = 9 ;
int MiniReed = 8;
 
int val ;
void setup ()
{
  pinMode (Relay, OUTPUT);
  pinMode (MiniReed, INPUT);
}
void loop ()
{
  val = digitalRead (MiniReed) ;
  if (val == HIGH)
  {
    digitalWrite (Relay, HIGH);
  }
  else
  {
    digitalWrite (Relay, LOW);
  }
}


http://blog.arduinosensors.nl/2016/11/02/arduino-magnetic-reed-switch-ky-021/
www.arduinosensors.nl




Entprellung von Reed-Kontakte
bzw. Micro-SchalterSchalter entprellen mit Arduino debounce Lib
die Prellzeit bei Reedkontakten < 1ms ist kleiner als bei normalen Schaltern 10ms.
http://www.arduino.cc/playground/Code/Bounce



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.20   KY-022 - IR-Empfänger/Decoder
Arduino KY-022
Infrarotsensor-Empfängermodul - IR receiver - VS1838B - 38kHz

Hierbei handelt es sich um einen VS1838B  IR-Empfänger mit integriertem Decoder für PCM (Puls-Code-Modulation)-Signale nach NEC- oder RC5-Standard 
im 38kHz Spektrum.
Data Formats for IR Remote Control
http://www.vishay.com/docs/80071/dataform.pdf

Empfangen - Infrarot VS1838B IR Receiver


Somit können die gängigen Infrarot-Sender (allen voran Fernbedienungen) ohne Umwege ausgewertet werden.
Das Modul kann mit einer Spannung von 2,7V .. 5,5V betrieben werden und ermöglicht Reichweiten von 8m .. 18 m.
Der Empfänger ist relativ unempindlich im Hinblick auf Umgebungslicht und liefert ein Rechtecksignal entsprechend des empfangenen modulierten Lichtsignals.
Die LED zeigt zusätzlich die empfangenen und decodierten Signale des Moduls.

FD Foto-Diode


Mein Modul ist so beschaltet
BlackBoard Circuit Designer Schaltplan

Beim elektor Schaltbild liegt LED-Anode an Signal und der Widerst. 1k an GND


KY-022 Infrared IR Sensor Receiver Module for Arduino

Specification:
Dimension            : 6,4 x 7,4 x 5,1mm
Receiving angle   : 90 °
Working voltage   : 2,7 .. 5,5V
Frequency             : 37.9kHz
Receiving range  : max. 18m


3-pin IR-Receiver  AX-1838HS

Arduino KY-022 Infrared sensor receiver module

Infrarot-Sensor, Typ VS1838B für Fernbedienung mit 38kHz Frequenz.
Betriebsspannung: 2,7..5,5V;     Frequenz: 37,9kHz;    Empfangsbereich: max. 18m,
Erfassungswinkel: 90°


Inhalt
    
1 Infrarotfernbedienung
    
2 Infrarot-Controller (in anderen TkkrLab Arduino Set)
        
2.1 Technische Daten
    
3 Verwendung
    
4 Prüfung
    
5 Schema
    
6 Beispielcode
    
7 Himbeere Pi2
        
7.1 Übung
        
7.2 pi mit dem Modul verdrahten
        
7.3 Raspbian einrichten
        
7.4 Beispielcode (Python)

Infrarotfernbedienung
Infrarot-Controller (in anderen TkkrLab Arduino Set)

Dies ist eine neue ultra-dünne 38K universelle Infrarot-Fernbedienung, mit dem NEC-Kodierung Format, vor allem für Autos Mit MP3, Fußbad, Beleuchtung Design ausgestattet, digitalen Fotorahmen, Microcontroller Development Board Lernboard und andere Anlässe.
Da es auf Non-Line-Fernbedienung basiert, so dass die Menschen scheinen einfach zu bedienen, effektiv, und jetzt mehr und mehr breite Anwendung Feld, dann für Dieses Produkt unserer Firma, dass wir die folgende Einführung.

Technische Daten
    
Infrarotfernsteuerungsabstand: mehr als 8 Meter
    
Startschlauch Infrarot-Wellenlänge: 940Nm
    
Kristallfrequenz: 455kHz Kristall
    
Trägerfrequenz: 38kHz
    
Encoding: Kodierungsformat für das NEC
    
Größe: 86 * 40 * 6mm
    
Leistung: CR2025 / 1600mAh

Benutzen
Denken Sie daran, dass die Fernbedienung und der IR-Empfänger ein Satz ist, muss er den Code dekodieren und einen Hex-Code anzeigen.


Test
    
Arduino Steuergerät
    
USB Datenkabel
    
Infrarotfernbedienung
    
Das Infrarotempfängermodul

Schema
    
Arduino GND -> Modulstecker -
    
Arduino + 5V -> Modul PLUS (mittlerer Stift)
    
Arduino Digital Pin 11 -> Baugruppe S


Beispielcode für ARDUINO UNO
Sketch KY-022


Dies ist der mitgelieferte Democode für das Arduino finden Sie unter Datei-> Beispiele-> IrRemote-> IrRecvDemo
/*
 * IRremote: IRrecvDemo - demonstrates receiving IR codes with IRrecv
 * An IR detector/demodulator must be connected to the input RECV_PIN.
 * Version 0.1 July, 2009
 * Copyright 2009 Ken Shirriff
 * http://arcfn.com
 */
 
#include <IRremote.h>
 
int RECV_PIN = 11;
 
IRrecv irrecv(RECV_PIN);
 
decode_results results;
 
void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn();     // Start the receiver
}
void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    irrecv.resume();       // Receive the next value
  }
}


https://tkkrlab.nl/wiki/Arduino_KY-022_Infrared_sensor_receiver_module
http://www.instructables.com/id/IR-Remote-Home-Control-Using-the-KY-022/
http://blog.arduinosensors.nl/2016/11/02/arduino-ir-remote-home-control-ky-022/
https://wiki.makehackvoid.com/workshops:archived:arduino_dxmodulepack

https://learn.adafruit.com/ir-sensor/using-an-ir-sensor


IR-Sensor


S=Out     G=GND       Vcc=5V

Größe: Quadrat, 7mm durch 8mm Detektorbereich
Preis: $ 2,00 im Adafruit-Shop
Ausgang: 0V (low) bei Detektion von 38kHz Träger, 5V (high) sonst
Empfindlichkeitsbereich: 800nm bis 1100nm mit Spitzenreaktion bei 940nm.
Der Frequenzbereich beträgt 35kHz bis 41kHz mit Spitzenerkennung bei 38kHz
Spannungsversorgung: 3..5Vdc 3mA
PNA4602 Datenblatt (jetzt nicht mehr lieferbar) oder GP1UX311QS oder TSOP38238 (pin-compatible replacements)



Wie Sie aus diesen Datenblattdiagrammen ersehen können, liegt die Peakfrequenzerfassung bei 38kHz und die Peak-LED-Farbe bei 940nm.
Sie können von etwa 35kHz bis 41kHz verwenden, aber die Empfindlichkeit wird abfallen, so dass es nicht auch aus der Ferne erkennen.
Ebenso können Sie 850 bis 1100nm LEDs, aber sie arbeiten nicht so gut wie 900 bis 1000nm so stellen Sie sicher, passende LEDs zu bekommen!
Überprüfen Sie das Datenblatt für Ihre IR-LED, um die Wellenlänge zu überprüfen.

Versuchen Sie, eine 940nm zu erhalten - denken Sie daran, dass 940nm nicht sichtbares Licht ist (sein Infrarot)!

  1. /* Raw IR decoder sketch!
  2. This sketch/program uses the Arduno and a PNA4602 to
  3. decode IR received. This can be used to make a IR receiver
  4. (by looking for a particular code)
  5. or transmitter (by pulsing an IR LED at ~38KHz for the
  6. durations detected
  7. Code is public domain, check out www.ladyada.net and adafruit.com
  8. for more tutorials!
  9. */
  10.  
  11. // We need to use the 'raw' pin reading methods
  12. // because timing is very important here and the digitalRead()
  13. // procedure is slower!
  14. //uint8_t IRpin = 2;
  15. // Digital pin #2 is the same as Pin D2 see
  16. // http://arduino.cc/en/Hacking/PinMapping168 for the 'raw' pin mapping
  17. #define IRpin_PIN PIND
  18. #define IRpin 2
  19. // for MEGA use these!
  20. //#define IRpin_PIN PINE
  21. //#define IRpin 4
  22.  
  23. // the maximum pulse we'll listen for - 65 milliseconds is a long time
  24. #define MAXPULSE 65000
  25.  
  26. // what our timing resolution should be, larger is better
  27. // as its more 'precise' - but too large and you wont get
  28. // accurate timing
  29. #define RESOLUTION 20
  30.  
  31. // we will store up to 100 pulse pairs (this is -a lot-)
  32. uint16_t pulses[100][2]; // pair is high and low pulse
  33. uint8_t currentpulse = 0; // index for pulses we're storing
  34.  
  35. void setup(void) {
  36. Serial.begin(9600);
  37. Serial.println("Ready to decode IR!");
  38. }
  39.  
  40. void loop(void) {
  41. uint16_t highpulse, lowpulse; // temporary storage timing
  42. highpulse = lowpulse = 0; // start out with no pulse length
  43. // while (digitalRead(IRpin)) { // this is too slow!
  44. while (IRpin_PIN & (1 << IRpin)) {
  45. // pin is still HIGH
  46.  
  47. // count off another few microseconds
  48. highpulse++;
  49. delayMicroseconds(RESOLUTION);
  50.  
  51. // If the pulse is too long, we 'timed out' - either nothing
  52. // was received or the code is finished, so print what
  53. // we've grabbed so far, and then reset
  54. if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
  55. printpulses();
  56. currentpulse=0;
  57. return;
  58. }
  59. }
  60. // we didn't time out so lets stash the reading
  61. pulses[currentpulse][0] = highpulse;
  62. // same as above
  63. while (! (IRpin_PIN & _BV(IRpin))) {
  64. // pin is still LOW
  65. lowpulse++;
  66. delayMicroseconds(RESOLUTION);
  67. if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
  68. printpulses();
  69. currentpulse=0;
  70. return;
  71. }
  72. }
  73. pulses[currentpulse][1] = lowpulse;
  74.  
  75. // we read one high-low pulse successfully, continue!
  76. currentpulse++;
  77. }
  78.  
  79. void printpulses(void) {
  80. Serial.println("\n\r\n\rReceived: \n\rOFF \tON");
  81. for (uint8_t i = 0; i < currentpulse; i++) {
  82. Serial.print(pulses[i][0] * RESOLUTION, DEC);
  83. Serial.print(" usec, ");
  84. Serial.print(pulses[i][1] * RESOLUTION, DEC);
  85. Serial.println(" usec");
  86. }
  87. // print it in a 'array' format
  88. Serial.println("int IRsignal[] = {");
  89. Serial.println("// ON, OFF (in 10's of microseconds)");
  90. for (uint8_t i = 0; i < currentpulse-1; i++) {
  91. Serial.print("\t"); // tab
  92. Serial.print(pulses[i][1] * RESOLUTION / 10, DEC);
  93. Serial.print(", ");
  94. Serial.print(pulses[i+1][0] * RESOLUTION / 10, DEC);
  95. Serial.println(",");
  96. }
  97. Serial.print("\t"); // tab
  98. Serial.print(pulses[currentpulse-1][1] * RESOLUTION / 10, DEC);
  99. Serial.print(", 0};");
  100. }


PWM ON OFF
2.5ms 0.6ms
1.2ms 0.6ms
0.6ms 0.6ms
1.2ms 0.6ms
0.6ms 0.6ms
1.2 ms 0.6 ms
0.6 ms 0.6 ms
0.6 ms 0.6 ms
1.2 ms 0.6 ms
0.6 ms 0.6 ms
0.6 ms 0.6 ms
0.6 ms 0.6 ms
0.6 ms 270 ms


https://learn.adafruit.com/ir-sensor/using-an-ir-sensor
https://learn.adafruit.com/ir-sensor/overview  
https://wiki.makehackvoid.com/workshops:archived:arduino_dxmodulepack
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-022    Infrarot Receiver

IR Receiver mit dem Arduino
In diesem Post geht es darum, wie man einen Infrarot Empfänger mit dem Arduino verbindet und IR Signale von Fernbedienungen ausliest.
Dieser Post ist Teil der Artikelserie über das Ultimate Arduino Sensor Kit mit 37 Sensoren. Das Kit, inklusive IR Receiver, gibt es hier auf Amazon. Den Sensor (KY 022) einzeln findet ihr hier auf Amazon.

Die Verbindung des Sensors mit dem Arduino gestaltet sich sehr einfach. Auf dem oberen Bild, wäre der linke Pin der Signal Pin, welcher mit Pin 11 des Arduino verbunden werden muss, der mittlere Pin +5V und der Rechte der Ground Pin.
Um nun Signale auszuwerten, muss man die IRremote Bibliothek verwenden. Diese kann man einfach über den Library Manager nachladen.

Da jeder Hersteller unterschiedliche IR Protokolle verwendet, damit sich nicht bei einem Knopfdruck plötzlich alle Geräte ausschalten, muss man jeweils den RAW Wert des Signals auslesen, da auch die IRremote Bibliothek nicht mit den kürzeren HEX Werten aller Hersteller zurechtkommt (beispielsweise Samsung Geräte werden teilweise nicht unterstützt).

Mit diesem Beispielsketch, findet ihr jeweils den RAW Wert heraus. Dazu musst du einfach nur den folgenden Sketch auf den Arduino laden, den Receiver mit ihm verbinden, und die serielle Konsole am PC öffnen.

Nun erhält man den RAW Code des jeweiligen Signals(an, aus, lauter, leiser, ...) der Fernbedienung für dein Endgerät, etwa den Fernseher, Stereoanlage, DVD Player, ...:
Nun hast du den einmaligen RAW Code des Signals. Mit diesem Verfahren, kannst du nun jede Fernbedienung mittels des IR Recievers in eine Universalfernbedienung für den Arduino verwandeln.

Wie man mit diesen RAW Werten und einer Infrarot LED die Geräte über den Arduino steuern kann, erfährst du im nächsten Post.


RAW_reader_IR_ardu.ino hosted with ❤ by GitHub



/*
* IRremote: IRrecvDump - dump details of IR codes with IRrecv
* An IR detector/demodulator must be connected to the input RECV_PIN.
* Version 0.1 July, 2009
* Copyright 2009 Ken Shirriff
* http://arcfn.com
*/

#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}

// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
// void * to work around compiler issue
//void dump(void *v) {
// decode_results *results = (decode_results *)v
void dump(decode_results *results) {
int count = results->rawlen;
if (results->decode_type == UNKNOWN) {
Serial.print("Unknown encoding: ");
}
else if (results->decode_type == NEC) {
Serial.print("Decoded NEC: ");
}
else if (results->decode_type == SONY) {
Serial.print("Decoded SONY: ");
}
else if (results->decode_type == RC5) {
Serial.print("Decoded RC5: ");
}
else if (results->decode_type == RC6) {
Serial.print("Decoded RC6: ");
}
else if (results->decode_type == PANASONIC) {
Serial.print("Decoded PANASONIC: ");
}
else if (results->decode_type == JVC) {
Serial.print("Decoded JVC: ");
}
else if (results->decode_type == SAMSUNG) {
Serial.print("Decoded SAMSUNG: ");
}
int val1 = results->value;
Serial.print(val1, HEX);
Serial.print(" (");
int valbits = results->bits;
Serial.print(valbits, DEC);
Serial.println(" bits)");
Serial.print("Raw (");
Serial.print(count, DEC);
Serial.print("): ");

for (int i = 0; i < count; i++) {
if ((i % 2) == 1) {
int valen = results->rawbuf[i]*USECPERTICK;
Serial.print(valen, DEC);

}
else {
int negvalen =-(int)results->rawbuf[i]*USECPERTICK;
Serial.print(negvalen, DEC);
}
Serial.print(", ");
}
Serial.println("");
}

void loop() {
if (irrecv.decode(&results)) {
int hexen = results.value;
Serial.println(hexen, HEX);
dump(&results);
irrecv.resume(); // Receive the next value
}
}





*********************************************************
3.21   KY-023 - Analoger Joystick mit Drucktaster
Arduino KY-023
XY-Achse Joystick-Modul - JoyStick

Print 33,5mm x 25,4mm

Arduino KY-023 XY-axis joystick module


Der analoge 2-Achsen Joystick liefert mittels zwei über Kreuz angeordneter 5k Linear-Potis Widerstandswerte für die XY-Stellung.

Der Bedienknopf wird aufgesteckt.

Durch drücken des Knopfes wird ein Taster geschlossen.

Der Pull-Up-Widerstand für den Taster ist zwar auf der Platine vorgesehen, aber nicht bestückt.


Joystick Pinbelegung nach elektor  2016-11s47   immer nach Sketch verbinden ! ! !

BlackBoard Circuit Designer Schaltplan
Links oder Unten 0,1k         Mittelstellung 3,25k        Rechts oder Oben 4,25k   


         Potentiometer Y-Aches und X-Achse

a
Anschlussbelegung Arduino:
Tast-Schalter  = pin-3
Y-Position       = pin-A1
X-Position       = pin-A0
Sensor +V      = 5V
Sensor GND  = GND

a
a


Steuerknüppel-Modul
Analoger Joystick mit 2x 10kOhm Potentiometer und Drucktaster.
Anschlussbeschreibung ist aufgedruckt, passender aufsteckbarer Knopf ist im Lieferumfang.


2x Poti 4,7k

Inhalt
    
1 PS2 Spiel Joystick-Achsensensor-Modul 2x 4,7k
    
2 Produktbeschreibung
    
3 Technische Daten
    
4 Prüfung
    
5 Schema
    
6 Beispielcode

PS2 Spiel Joystick Achsensensor-Modul

Produktbeschreibung

Das Unternehmen produziert PS2 Spiel Joystick-Achsensensor-Modul besteht aus der Verwendung von Original-Qualität Metall PS2 Joystick-Potentiometer-System
Für die (X, Y) ein 2-Achsen-Analogausgang und für (Z) 1 Digitalausgang Kanal-Taste.

Technische Daten
Der Joystick ist eine Kombination aus 2 analoog Potentiometer und einem digitalen Schalter.

Test
    
Arduino Steuergerät
    
USB Datenkabel
    
PS2 Spielsensormodul

Schema

    Arduino Digital               -> Modul (Taster) SW
    Arduino Analoog 1      -> Modul VRy
    Arduino Analoog 0  -> Modul VRx
    Arduino + 5V            -> Baugruppenträger + 5V
   
Arduino GND              -> Modul-GND





Benötigen Sie einen Widerstand, können Sie Arduino internen Pullup-Widerstand, Befehl (pinMode (Pin, INPUT_PULLUP);) verwendet den Job


Beispielcode für ARDUINO UNO
Sketch KY-023

// Module KY023
// For more info see http:  //tkkrlab.nl/wiki/Arduino_KY-023_XY-axis_joystick_module
int JoyStick_X = A0;        // x
int JoyStick_Y = A1;        // y
int JoyStick_Z = 3;         // key
void setup ()
{
  pinMode (JoyStick_X, INPUT);
  pinMode (JoyStick_Y, INPUT);
  pinMode (JoyStick_Z, INPUT_PULLUP);
  Serial.begin (9600);      // 9600 bps
}
void loop ()
{
  int x, y, z;
  x = analogRead (JoyStick_X);
  y = analogRead (JoyStick_Y);
  z = digitalRead (JoyStick_Z);
  Serial.print (x, DEC);
  Serial.print (",");
  Serial.print (y, DEC);
  Serial.print (",");
  Serial.println (z, DEC);
  delay (100);
}

https://tkkrlab.nl/wiki/Arduino_KY-023_XY-axis_joystick_module




// Deklaration und Initialisierung der Eingang-Pins
int JoyStick_X = A0;     // X-Achse-Signal
int JoyStick_Y = A1;     // Y-Achse-Signal
int Button = 3;          // Knopf
 
void setup ()
{
  pinMode (JoyStick_X, INPUT);
  pinMode (JoyStick_Y, INPUT);
  pinMode (Button, INPUT);
   
  // Da der Knopf das Signal beim druecken auf Masse zieht,
  // schalten wir hiermit den PullUp-Widerstand ein
  digitalWrite(Button, HIGH); 
   
  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 x, y;
  int Knopf;
   
  //Aktuelle Werte werden ausgelesen, auf den Spannungswert konvertiert...
  x = analogRead (JoyStick_X) * (5.0 / 1023.0);
  y = analogRead (JoyStick_Y) * (5.0 / 1023.0);
  Knopf = digitalRead (Button);
   
  //... und an dieser Stelle ausgegeben
  Serial.print ("X-Achse:"); Serial.print (x, 4);  Serial.print ("V, ");
  Serial.print ("Y-Achse:"); Serial.print (y, 4);  Serial.print ("V, ");
  Serial.print ("Knopf:");
 
  if(Knopf==1)
  {
      Serial.println (" nicht gedrueckt");
  }
  else
  {
      Serial.println (" gedrueckt");
  }
  delay (200);
}



KY-023_Joystick_Modul.zip
http://www.linkerkit.de/index.php?title=KY-023_Joystick_Modul_(XY-Achsen)



Anschließen eines Joysticks







Der Joystick in der Abbildung ist nichts als zwei 10k linear Potentiometer, die uns erlauben, die Bewegung des Stockes in 2-D zu messen.
Potentiometer sind variable Widerstände und wirken in gewisser Weise als Sensoren, die eine variable Spannung liefern, die von der Drehung der Vorrichtung um ihre Welle abhängt.

Die Art des Programms, das wir brauchen, um den Joystick zu überwachen, muss eine Abfrage zu zwei der analogen Pins machen.
Wir können diese Werte an den Rechner zurückschicken, aber dann stehen wir vor dem klassischen Problem, dass die Übertragung über den Kommunikations
- Port mit 8-bit Werten erfolgen muss, während unser DAC
(Digital - Analog - Wandler - das heißt die Messwerte der Potentiometer in
Der Joystick)
hat eine Auflösung von 10-bit.

Mit anderen Worten bedeutet dies, dass unsere Sensoren mit einem Wert zwischen 0 und 1024 charakterisiert sind.

Der folgende Code enthält eine Methode namens treatValue (), die das Messgerät des Sensors in einen Wert zwischen 0 und 9 transformiert und in ASCII zurück an den Computer sendet.
Dies ermöglicht es, die Informationen einfach in
z.B.
Blitz und analysieren Sie es in Ihrem eigenen Code.

Schließlich blinkt die LED mit den von den Sensoren gelesenen Werten als direkte visuelle Rückmeldung, wie wir den Joystick steuern.



 /* Read Jostick
  * ------------
  *
  * Reads two analog pins that are supposed to be
  * connected to a jostick made of two potentiometers
  *
  * We send three bytes back to the comp: one header and two
  * with data as signed bytes, this will take the form:
  *     Jxy\r\n
  *
  * x and y are integers and sent in ASCII
  *
  * http://www.0j0.org | http://arduino.berlios.de
  * copyleft 2005 DojoDave for DojoCorp
  */


 int ledPin = 13;
 int joyPin1 = 0;                 // slider variable connecetd to analog pin 0
 int joyPin2 = 1;                 // slider variable connecetd to analog pin 1
 int value1 = 0;                  // variable to read the value from the analog pin 0
 int value2 = 0;                  // variable to read the value from the analog pin 1

 void setup() {
  pinMode(ledPin, OUTPUT);              // initializes digital pins 0 to 7 as outputs
  Serial.begin(9600);
 }

 int treatValue(int data) {
  return (data * 9 / 1024) + 48;
 }

 void loop() {
  // reads the value of the variable resistor
  value1 = analogRead(joyPin1);  
  // this small pause is needed between reading
  // analog pins, otherwise we get the same value twice
  delay(100);            
  // reads the value of the variable resistor
  value2 = analogRead(joyPin2);  

  digitalWrite(ledPin, HIGH);          
  delay(value1);
  digitalWrite(ledPin, LOW);
  delay(value2);
  Serial.print('J');
  Serial.print(treatValue(value1));
  Serial.println(treatValue(value2));
 }


https://www.arduino.cc/en/Tutorial/JoyStick


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-023    Joystick

Joystick mit dem Arduino
In diesem Post geht es darum, wie man einen Joystick mit dem Arduino verbindet und ausließt.
Dieser Post ist Teil der Artikelserie über das Ultimate Arduino Sensor Kit mit 37 Sensoren. Das Kit, inklusive Joystick, gibt es hier auf Amazon. Den Joystick einzeln findet ihr hier auf Amazon.

Funktionsweise

Ein Joystick für den Arduino besteht eigentlich nur aus zwei Potentiometern, und optional einem Button. Dabei gibt es ein Potentiometer für die x Achse, und Eins für die y Achse. Wenn der Joystick "neutral" steht, sind beide bei 1023/2, also 512. Die aktuellen Werte kann man mittels einem analog Eingang jeweils für die x Achse und für die y Achse auslesen.
Zusätzlich gibt es bei manchen Joysticks noch einen integrierten Button, wodurch man den Joystick drücken kann, um eine zusätzliche Aktion auszuführen.
Die Verkabelung ist sehr einfach, da die Pins beschriftet sind. Zur Stromversorgung benötigt man +5V und den Ground. Zusätzlich dazu gibt es jeweils einen Pin für die beiden Potentiometer und einen Pin für das Signal des Buttons.

Auslesen des Joysticks

Um den Joystick auszulesen, muss man nur die beiden analog Eingänge mit den Signalen der Potentiometer auslesen. Die rechte obere Ecke wäre dann beispielsweise x: 800 - 1000 und y: 800 - 1000.
Durch das Einbauen dieser Überlegungen in den Quelltext, oder das direkte Arbeiten mit den Werten, beispielsweise repräsentiert die x Achse die Blinkdauer, und die y Achse die Leuchtstärke, kann man den Joystick in den Arduino Code einbauen.
Der große Vorteil eines Joysticks, dass man über einen Finger gleich zwei analoge Signale schalten kann, kommt insbesondere bei einem Display zum Vorschein.
joystick_ardu.ino hosted with ❤ by GitHub


Hier einmal ein einfacher Beispielcode für den Joystick:

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

void loop() {
    Serial.print("X: ");
    Serial.print(analogRead(A0));
    Serial.print(" Y: ");
    Serial.print(analogRead(A1));
    Serial.print(" Button: ");
    Serial.println(digitalRead(2));
    delay(10);
}



*********************************************************
3.22 KY-024 - Magnetfeld-/Hall-Sensor mit Dual-Komparator 49E
bipolare Hall-Sensor HAL501
Arduino KY-024
Linearmagnetische Hall-Sensoren - Linear Hall - Hall-Sensor 49E 504BG
2 Stk wurden geliefert
Linear Hall Sensoren 49E   49E (504BG)      3144LUA-S        SS49E      SS495B
Linear magnetic Hall sensors A3141  49E504BG
https://www.elecrow.com/download/A3141-2-3-4-Datasheet.pdf

https://community.medion.com/t5/Smart-Home/Passiert-eigentlich-noch-was/m-p/51359

Arduino KY-024 Linear magnetic Hall sensors

Arduino KY 024 Linear Hall Magnetic Module

SS49E Analog linear magnetic Hall Sensor Modul for Arduino KY-024






pin-D0   = digitales Signal
+             = +5V
G            = GND
pin-A0   = analoges Signal

ACHTUNG pin-?? genau nach Sketch anschließen

Anschlussbelegung ARDUINO UNO Rev.3
digitales Signal      =  pin-3
+V                             =   pin 5V
GND                        =  pin GND
analoges Signal   =  pin-A0

LM393 - Low power dual voltage comparator


LM393 - Low Offset Voltage Dual Comparators
Der auf diesem Modul verbaute bipolare Sensor 49E (HAL501)  ist besonders empindlich in Bezug auf Magnetfelder.
Die Sensorläche beindet sich auf der bedruckten Vorderseite (Seite mit den abgeschrägte Ränder) im oberen Bereich in etwa hinter dem oberen Aufdruck.
Der auf dem Modul integrierte Dual-Komparator ermöglicht das Einstellen einer Schaltschwelle mit dem 25-Gang Trimmer.
So kann das Modul auch als Schalter verwendet werden, ohne analoge Meßsignal auswerten zu müssen.
25-Gang Trimmer besitzen keinen Endanschlag sondern eine Rutschkupplung.
Wenn Sie beim Drehen in eine Richtung ein leises Klicken vernehmen, haben Sie den Trimmer in der betrefenden Richtung bis zum Ende gedreht.
LED1 leuchtet permanent wenn Modul mit Spannung versorgt ist.
LED2 leuchtet extrem schwach, wenn ein Magnetfeld erkannt wurde. 1k Vorwiderstand könnte zu hoch sein.

Am Ausgang pin-DO (Digital-Out)  liegt das Digitale-Schaltsignal an, welches auf 5V ansteigt, wenn der Komparator LM393 A=1 schaltet.
An pin-AO (Analog Out) liegt der analoge Messwert des Linear-Hall-Sensors.




BlackBoard Circuit Designer Schaltplan - ein Bypaß-Kondensator von 100nF FEHLT zwischen Vcc und GND am Modul


DO = Digital Out - - - ARDUINO UNO R3 auf pin-A1
+                            - - - ARDUINO UNO R3 auf +5V
G                           - - - ARDUINO UNO R3 auf  GND
AO = Analog Out - - - ARDUINO UNO R3 auf pin-A2

 
Die im elektor BUCH  SENSOREN AM ARDUINO gezeigte Schaltung ist wie viele andere im BUCH veröffentlichte Sensor-Schaltungen natürlich FALSCH ! ! !



Hall-Effekt-Sensor-Familie für den universellen Einsatz
Kurzbeschreibung
Hinweis:
Die HAL 5xy Sensor-Familie wird nicht für Neuentwicklungen empfohlen und wird durch HAL 15xy ersetzt.

Die HAL 5xy Familie besteht aus verschiedenen Hall-Schaltern, die in CMOS-Technologie hergestellt werden.
Alle Sensoren beinhalten ein temperaturkompensiertes Hall-Element mit aktiver Offset-Kompensation und einen Komparator.
Je nach Familienmitglied wird der Schaltzustand über einen Open-Drain-Transistor oder durch Modulation des Versorgungsstroms ausgegeben (Zwei-Draht Hall-Effekt-Sensor).
Der Komparator vergleicht den tatsächlichen magnetischen Fluss durch das Hall-Element (Hallspannung) mit den festgelegten Bezugswerten (Schaltpunkten).
Dem entsprechend wird der Ausgangstransistor ein- oder ausgeschaltet.
Die Sensoren dieser Familie unterscheiden sich im Schaltverhalten und in den Schaltpunkten.
Der aktive Offset-Abgleich führt zu konstanten magnetischen Eigenschaften über Versorgungsspannung und Temperatur.
Außerdem sind die magnetischen Parameter robust gegnüber mechanischem Stress.
Die Sensoren sind für Anwendungen im Automobil und in der Industrie ausgelegt und können mit 3,8V bis 24V Versorgungsspannung im Sperrschichttemperaturbereich von –40 °C bis 170 °C betrieben werden.
Die Sensoren sind im SMD-Gehäuse SOT89B und in der bedrahteten Version TO-92UA erhältlich.
Der Hall-Effekt-Sensor besteht aus einer monolithischen Integrierten Schaltung dessen Ausgang auf ein äußeres Magnetfeld reagiert.
Wenn dessen Feldlinien den empfindlichen Bereich des Sensors rechtwinklig durchdringen, erzeugt das vorgespannte Hall-Element des Sensors eine zum Magnetfeld proportionale Spannung.
Diese Hall-Spannung wird im Komparator mit einem Referenzwert verglichen.
Die temperaturabhängige Vorspannungsregelung erhöht die Versorgungsspannung der Hall-Elemente und passt die Schaltpunkte der abnehmenden Feldstärke der Magneten bei höheren Temperaturen an. Überschreitet die Flussdichte die Schwellwerte, schaltet der Open-Drain-Ausgang in den entsprechenden Zustand.
Die integrierte Hysterese verhindert Schwingungen und sorgt so für ein prellfreies Schaltverhalten.

https://www.micronas.com/de/produkte/hall-schalter/hal-5xy

HAL 1501

https://www.micronas.com/en/system/files/downloads/files/HAL15xy_First%20ISO%2026262%20Compliant%20Low-Power%20Hall%20Switch_4PI.pdf



Arduino KY-024 Linear magnetic Hall sensors

Hall Effect Magnetic Sensor Module DC 5V For Arduino

Linear Hall Magnetic IC 3-pin  3144LUA-S ODER 49E504BG
Op-Amp LM393
Trimmer 100k

Linearer Hall Sensor zur Erkennung eines Magnetfelds vor dem Sensor.
Abhängig von Stärke, Polarisation und Position des Magneten vor dem Sensor, schaltet der „DO“ Ausgang auf high-Pegel (high active).
Die Empfindlichkeit kann mit dem Potentiometer eingestellt werden.
Zusätzlich liegt am Anschluss „AO“ das analoge Si
gnal des Sensors an.


Magnetisches Linearmodul
Lineare Halle magnetische Modul und eine digitale Schnittstelle, eingebaute 13 LED bauen eine einfache Schaltung zur Herstellung einer Magnetfeld-Warnlampe 13 kommt mit digitalen Schnittstellen der LED, die lineare Hall-Sensor-Magnetometer Zugang Nummer 3-Schnittstelle, wenn lineare Hall-Magnetometer Sensor erfasst Ein Tastensignal, LED leuchtet, andernfalls aus.


Beispielcode für ARDUINO UNO
Sketch KY-024

int Led = 13 ; // define LED Interface
int buttonpin = 3; // define the linear Hall magnetic sensor interface
int val ; // define numeric variables val
void setup ()
{
  pinMode (Led, OUTPUT) ; // define LED as output interface
  pinMode (buttonpin, INPUT) ; // define linear Hall magnetic 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 linear Hall sensor detects a magnetic signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}

https://tkkrlab.nl/wiki/Arduino_KY-024_Linear_magnetic_Hall_sensors



KY-024 Linear magnetic Hall Sensor



Technische Daten / Kurzbeschreibung

Chipsatz: A3141 | OP-Verstärker: LM393
Das Magnetfeld wird vom Sensor gemessen und als analoger Spannungswert ausgegeben.
Die Empfindlichkeit des Sensors kann mittels des Potentiometers geregelt werden.

Digitaler Ausgang: Wird ein Magnetfeld erkannt, so wird hier ein Signal ausgegeben
Analoger Ausgang: Direkter Messwert der Sensoreinheit

LED1: Zeigt an, dass der Sensor mit Spannung versorgt ist
LED2: Zeigt an, dass ein Magnetfeld detektiert wurde


Funktionsweise des Sensors

Dieser Sensor besitzt auf seiner Platine drei funktionelle Bestandteile.
Die 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:
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);
}



http://www.linkerkit.de/index.php?title=KY-024_Linear_magnetic_Hall_Sensor



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.


Gauss-Meter
Linear Hall Sensor 49E 504BG = SS49E = SS495B


https://arduining.com/2012/07/17/arduino-hall-effect-sensor-gaussmeter/

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.23   KY-025 - Reed-Schalter mit Komparator
Arduino KY-025
Reed-Schalter Modul - Reed switch
Niemand brauch bei einem Reedschalter einen Dual-Komparator LM393D
Löten Sie den Reedkontakt aus und löten dafür einen Analog-Sensor ein.

Für einen Reedkontakt brauchen Sie weder das Modul KY-025 mit LM393 noch das einfachere Modul KY-021




Der Komparator dient eigentlich dazu, einen analogen Messwert mit einem anderen Wert zu vergleichen und dann zu schalten.
Mit dem Trimmer lässt sich nicht die Empindlichkeit des Reedschalters justieren.
LED1 leuchtet permanent, LED2 leuchtet, wenn der Reedschalter geschlossen ist.
Am Ausgang D0 liegt das Schaltsignal an, welches auf 5 V ansteigt, wenn der Komparator schaltet.

Anschlussbelegung Arduino:

A0 digitales Signal = [Pin 3]
+V = [Pin 5V]
GND = [Pin GND]
D0 analoges Signal = [Pin 0]

oder auch
Arduino KY-021 Kleines Reed-Schalter Modul - Mini Reed


Arduino KY-025 Reed-Module die Idee eines Scherzboldes.

BlackBoard Circuit Designer Schaltplan - ein Bypaß-Kondensator von 100nF FEHLT zwischen Vcc und GND am Modul

Mini Reed-Kontakt, verbindet die beiden äußeren Pins der Platine.
Ohne Magnetfeld ist der Kontakt offen.
Eingebauter 10kOhm Widerstand als Pull-up oder Pull-down zwischen dem mittleren und dem „S“-Anschluss.



Reed-Modul

Reed-Modul und die Schnittstelle kommt mit digitalen 13 LED bauen eine einfache Schaltung, um eine Reed-Warnlampe 13 kommt mit digitalen Schnittstellen der LED, die Reed-Sensor Zugang Nummer 3-Schnittstelle, wenn Reed-Sensoren Erfasst ein Schlüsselsignal (Magnetfeld ändern in der Nähe der Modul), LED leuchtet, andernfalls aus.

Beispielcode 2 getestet und funktioniert gut mit Tutorial von: arduinolearning.com arduinolearning.com

Beispielcode 1 für ARDUINO UNO
Sketch KY-025

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



Beispielcode 2 für ARDUINO UNO
Sketch KY-025


Von arduinolearning.com (Arbeiten mit dem dargestellten Modul und arduino uno clone)

// Arduino pin numbers
//D2 and A0 used on board and connected to D0 and A0 on the module
//G ground
//+ 5V
//open arduino console - upload the code and watch the result
 
const int digital = 2;
const int analog = 0;
 
void setup()
{
pinMode(digital, INPUT);
Serial.begin(115200);
}
 
void loop()
{
Serial.print(digitalRead(digital));
Serial.print("-");
Serial.println(analogRead(analog));
delay(250);
}

https://tkkrlab.nl/wiki/Arduino_KY-025_Reed_module



KY-025 Reed Modul

Technische Daten / Kurzbeschreibung
Wird ein Magnetfeld detektiert, so wird dies am digitalen Ausgang ausgegeben.
Reed-Kontakte haben die Eigenschaft, daß deren zwei dünnen Kontaktfedern, die sich im Inneren des Glasröhrchen befinden, aufeinander zu bewegen, falls ein Magnetfeld in der Nähe ist.


So wird ein elektrischer Kontakt geschlossen, welcher dann das Signal durchschaltet.
Digitaler Ausgang:
Wird ein Magnetfeld erkannt, so wird hier ein Signal ausgegeben
Analoger Ausgang:
Direkter Messwert der Sensoreinheit
LED1:
Zeigt an, dass der Sensor mit Spannung versorgt ist
LED2:
Zeigt an, dass ein Magnetfeld detektiert wurde

Funktionsweise des Sensors
Dieser Sensor besitzt auf seiner Platine drei funktionelle Bestandteile.
Die 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:
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-025_Reed_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




*********************************************************
3.24   KY-026 - IR-Sensor mit Komparator
Arduino KY-026
Flammenfühler-Modul - Flame
Flamm-Sensor-Modul
IR-Fotodiode

Dieses Modul wird als Sensor zur Erkennung von Flammen verkauft.
Tatsächlich handelt es sich einfach nur um eine dunkle 5 mm IR-Foto-Diode unbekannten Typs an einem Dual-Komparator LM393.
Weil Flammen auch einen Anteil IR-Licht ausstrahlen, kann mit dem Modul auch ein Feuer erkannt werden.
Mit dem 25-Gang Trimmer lässt sich der Schwellwert und somit die Empindlichkeit einstellen.
LED1 leuchtet permanent,
LED2 leuchtet, wenn der Schwellwert erreicht wurde.

Am Digital-Ausgang pin-DO liegt das Schaltsignal an, welches auf 5Vdc ansteigt, wenn der Komparator schaltet.




AO - Analog Output
     GND
          +Vcc
              DO - Digital Output
IR-Foto-Transistor BPW40



IR-Fotodiode 800nm bis 1000nm
IR-Photodioden als IR-Empfänger  (Lichtschranke)
BPX48  BPX61
BPV10  BPV10NF
BPW17N BPW20 BPW21 BPW21R BPW32 BPW34  BPW40 BPW41  BPW41N  BPW42 BPW43  BPW76A BPW104
BP104F  BP104S  BP104FS   BP104FAS
BPX63
SFH203  SFH203P  SFH206K  SFA213FA  SFH229FA  SFH485P  SFH203PFA   SFH2030
S1337-66BR
INFD5940



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.


BlackBoard Circuit Designer Schaltplan - ein Bypaß-Kondensator von 100nF FEHLT zwischen Vcc und GND am Modul


Anschlussbelegung Arduino:

digitales Signal = [Pin 3]
+V = [Pin 5V]
GND = [Pin GND]
analoges Signal = [Pin 0]

Arduino KY-026 Flame sensor module

Flame-Sensor mit Fotodiode zur Erkennung offenen Feuers.
Die spektrale Empfindlichkeit der LED ist auf offene Flammen abgestimmt.
Wird ein Feuer erkannt, schaltet der „DO“ Ausgang auf „high“ Pegel (high active).
Die Schaltschwelle (Empfindlichkeit) kann mit dem Potentiometer justiert werden.
Zusätzlich gibt der Sensor am „AO“ Anschluss auch ein analoges Signal aus.
Spektrale Empfindlichkeit: ca. 720nm..1100nm
Erfassungswinkel: ca. 60°


KEYES ARDUINO Flammmodul
Flammenmodul Interface-Modul und Nummer 13 kommt mit LED bauen eine einfache Schaltung zu produzieren Flamme Warnlampe 13 kommt mit digitalen Schnittstellen der LED, der Flammenfühler angeschlossen digitale drei Schnittstellen, wenn der Flammenfühler erkennt
Es gibt Schlüsselsignal erkannt, LED leuchtet,
Sonst ausgeschaltet.

Sensor für Flammenwellenlängen zwischen 760nm bis 1100nm Infrarot ist am empfindlichsten 60 Grad Erkennungssensor
Zwei Ausgänge Modus:
AO: Analogausgang- Echtzeit-Ausgangsspannung Signal auf den thermischen Widerstand
DO: wenn die Temperatur eine bestimmte Schwelle erreicht - der Ausgang hoch

Und niedrige Signalschwelle über Potentiometer einstellbar

Schema
     Arduino GND -> Baugruppe G
     Arduino + 5V -> Modul +
     Arduino digital 4 -> Baugruppe DO
     Arduino A3 -> Modul AO


Beispielcode für ARDUINO UNO
Sketch KY-026

//Example for KY-026
//TkkrLab
int Led = 13 ;// define LED Interface
int buttonpin = 3; // define the flame sensor interface
int analoog = A3; // define the flame sensor interface
 
int val ;// define numeric variables val
float sensor; //read analoog value
 
void setup ()
{
  pinMode (Led, OUTPUT) ;// define LED as output interface
  pinMode (buttonpin, INPUT) ;// output interface defines the flame sensor
  pinMode (analoog, INPUT) ;// output interface defines the flame sensor
  Serial.begin(9600);
}
 
void loop ()
{
  sensor = analogRead(analoog);
  Serial.println(sensor);  // display tempature
 
  val = digitalRead (buttonpin) ;// digital interface will be assigned a value of 3 to read val
    if (val == HIGH) // When the flame sensor detects a signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
  delay(1000);
}


https://tkkrlab.nl/wiki/Arduino_KY-026_Flame_sensor_module
http://www.instructables.com/id/DIY-Flame-Sensor-Alarm-Using-KY-026/
http://learn.linksprite.com/arduino/sensors-kit-for-arduino/ky026-flame-sensor-module/




KY-026 Flamen-Sensor Modul

Technische Daten / Kurzbeschreibung

Die angebrachte Fotodiode ist empfindlich auf den Spektralbereich von Licht, welches von offenen Flamen erzeugt wird.
Digitaler Ausgang: Wird eine Flame erkannt, wird hier ein Signal ausgegeben
Analoger Ausgang: Direkter Messwert der Sensoreinheit
LED1: Zeigt an, dass der Sensor mit Spannung versorgt ist
LED2: Zeigt an, dass ein Magnetfeld detektiert wurde

Funktionsweise des Sensors

Dieser Sensor besitzt auf seiner Platine drei funktionelle Bestandteile.
Die 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:
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-026_Flamen-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



Flame Sensor Alarm using KY-026



http://elektronik-kurs.net/elektronik/fotodiode/

http://www.instructables.com/id/DIY-Flame-Sensor-Alarm-Using-KY-026/

http://www.grund-wissen.de/elektronik/bauteile/diode.html



IR-LICHTSCHRANKE (Dunkelschaltung) - Winkler Schulbedarf

https://www.winklerschulbedarf.com/Documents/Anleitungen_Werkpackungen/PDF_Ger/101448.pdf


Gabellichtschranke TCST 2103 Vishay TCST 2103 GaAs-IR-Lumin.-Diode Reichweite 3.1 mm

Gabellichtschranke TCST 2103 Vishay TCST 2103 GaAs-IR-

https://www.conrad.at/de/gabellichtschranke-tcst-2103-vishay-tcst-2103-gaas-ir-lumin-diode-reichweite-31-mm-184250.html




KY-026      Flame Sensor

Flame Sensor

In diesem Post geht es darum, wie man einen Flame Sensor mit dem Arduino verwendet. Dadurch kann man überprüfen, ob gerade eine Feuer oder eine Kerze brennt.


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

Die Verkabelung

Die Verbindung des Sensors mit dem Arduino ist sehr einfach, da die Pins beschriftet sind. G muss mit dem Ground verbunden werden, und + mit den +5V des Arduino. Auch bei diesem Sensor hat man die Wahl, ob man ein analoges Signal(eventuell Stärke der Flamme), oder ein digitales Signal(Flame ja oder nein?) bekommen möchte.

Dabei kann ich nur das digitale Signal empfehlen. Das liegt daran, dass der Flame Sensor auch Lampen zu einem gewissen Teil als Feuer interpretiert, da manche Lampen das selbe IR Licht aussenden, wie typischerweise Feuer. Dadurch misst der Sensor in manchen Lichtbereichen ein konstantes Grundbrennen, welches aber beim digitalen Signal ignoriert wird.

Hier erhält man HIGH, wenn der Sensor ein Feuer entdecken sollte, und LOW, wenn nichts brennt. Dabei hat der Sensor einen relativ großen Einfallswinkel.

Zusätzlich befindet sich auf dem Sensor Modul auch eine zusätzliche rote LED, welche aktiviert wird, sobald der Sensor ein Feuer entdeckt.

Flame_Sensor_Ardu.ino hosted with ❤ by GitHub

Der Sketch

Im Sketch muss man eigentlich nur den entsprechenden Eingang des Arduino auslesen, und überprüfen ob dieser auf LOW oder HIGH steht:


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

}

void loop() {
if(digitalRead(3) == HIGH)
{
Serial.println("Feuer!");
}
else {
Serial.println("Kein Feuer...");
}
}





*********************************************************
3.25   KY-027 - LED und Quecksilberschalter
2x
vorhanden Arduino KY-027
Neigungsschalter & 5mm-LED - Light Cup
ODER
Arduino KY-017 Quecksilber-Schalter & SMD-LED - Tilt switch
ACHTUNG: KY-017 und KY-027 in Europa verboten - enthält Quecksilber.

Besser Sie verwenden das

Arduino KY-020 Kippschaltermodul - Ball switch - Kugelschalter

Modul                      Arduino UNO
Pin-L (LED)             pin-13
Pin-S (Schalter)       pin-3
Pin +                       pin +5V
Pin-G                      pin-GND
Bitte beachten Sie die Sicherheitshinweise, die bereits bei Modul KY-017 aufgeführt sind!


Auf diesem Modul sind zwei Bauteile vorhanden:
Eine rote 5mm LED im klaren Gehäuse und ein Quecksilberschalter.
Beide Bauteile können unabhängig voneinander verwendet werden.
Für die LED ist ein entsprechender externer Vorwiderstand  330R  erforderlich.
Für den Taster beindet sich ein 10k Pull-Up Widerstand auf dem Modul.

Anschlussbelegung Arduino:
LED +                  = [Pin 13]
LED -                  = [Pin GND]
Sensor Signal  = [Pin 10]
Sensor +V         = [Pin 5V]
Sensor -             = [Pin GND]

Arduino KY-027 Magic light cup module

BlackBoard Circuit Designer Schaltplan  ACHTUNG: LED Vorwiderstand von 330R fehlt am Print


Light Cup:
Kombination aus Quecksilber-Schalter und klarer roter LED auf einer Platine.
„G“ ist der gemeinsame Minuspol von Schalter und Kathode der LED.
„S“ ist der Schaltkontakt ,
„L“ die Anode der LED (Vorwiderstand nicht vergessen, 220 .. 330 Ohm).
Am „+“ Anschluss ist ein 10kOhm Pull-up Widerstand mit dem Schalter (S) verbunden.



Magic Licht Tasse-Modul

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


Beispielcode für ARDUINO UNO
Sketch KY-027

int LedPinA = 5;
int LedPinB = 6;
int ButtonPinA = 7;
int ButtonPinB = 4;
int buttonStateA = 0;
int buttonStateB = 0;
int brightness = 0;
void setup ()
{
  pinMode (LedPinA, OUTPUT);
  pinMode (LedPinB, OUTPUT);
  pinMode (ButtonPinA, INPUT);
  pinMode (ButtonPinB, INPUT);
}
void loop ()
{
  buttonStateA = digitalRead (ButtonPinA);
  if (buttonStateA == HIGH && brightness! = 255)
  {
    brightness + +;
  }
  buttonStateB = digitalRead (ButtonPinB);
  if (buttonStateB == HIGH && brightness! = 0)
  {
    brightness -;
  }
  analogWrite (LedPinA, brightness); // A few Guan Yuan (ii) ? 
  analogWrite (LedPinB, 255 - brightness);// B Yuan (ii) a few Bang ?
  delay (25);
}

Anmerkung:
Dieses Experiment erfordert zwei Module gleichzeitig.


https://tkkrlab.nl/wiki/Arduino_KY-027_Magic_light_cup_module
http://www.instructables.com/id/Arduino-Mercury-Switch-TILT-ALARM-With-the-KY-027-/


KY-027 Magic Light Cup Modul



Technische Daten / Kurzbeschreibung

Die LED wird bei Erschütterung an– oder ausgeschaltet.
Das Signal, wann die LED an ist, wird an einen Signalausgang gegeben.
Je nach Eingangsspannung, werden Vorwiderstände benötigt

Vorwiderstand:
Rv (3,3V) [Rot]= 120R
[z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie Raspberry-Pi]
Rv (5,0V) [Rot] = 220R
z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie Arduino

Codebeispiel Arduino

Hier bei handelt es sich um ein Beispielprogramm, welches die LED vom Magic-LightCup-Modul zum Leuchten bringt, wenn am Sensor eine Neigung detektiert wurde.


int Led = 13 ;// Deklaration des LED-Ausgangspin
int Sensor = 10; // Deklaration des Sensor-Eingangspin
int val; // Temporaere Variable
  
void setup ()
{
  pinMode (Led, OUTPUT) ; // Initialisierung Ausgangspin
  pinMode (Sensor, INPUT) ; // Initialisierung Sensorpin
  digitalWrite(Sensor, HIGH); // Aktivierung interner Pull-Up Widerstand
}
  
void loop ()
{
  val = digitalRead (Sensor) ; // Das gegenwärtige Signal am Sensor wird ausgelesen
  
  if (val == HIGH) // Falls ein Signal erkannt werden konnte, wird die LED eingeschaltet.
  {
    digitalWrite (Led, LOW);
  }
  else
  {
    digitalWrite (Led, HIGH);
  }
}


SensorTest_Arduino.zip

http://www.linkerkit.de/index.php?title=KY-027_Magic_Light_Cup_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.26   KY-028 - Analoger Temperatursensor mit Dual-Komparator
Arduino KY-028
Temperatursensormodul - Digital temp

KY-028 Temperatur Sensor Modul (10k NTC Thermistor)

Temperaturfühler-Modul


Es gibtb auch die Analog Temperatur Module  KY-013

Arduino KY-028 Temperature sensor module

Temperaturmessbereich: -55°C / +125°C

Dieses Modul beinhaltet einen 10k NTC Thermistor—dieser hat bei höherer Temperatur einen immer weniger werdenden Widerstandswert.
Digitaler Ausgang: Wird eine Temperatur über einen Grenzwert gemessen so wird dieses hier ausgegeben—der Grenzwert kann mittels des Potentiometers eingestellt werden
Analoger Ausgang: Direkter Messwert der Sensoreinheit
LED1: Zeigt an, dass der Sensor mit Spannung versorgt ist
LED2: Zeigt an, dass ein Magnetfeld detektiert wurde

BlackBoard Circuit Designer Schaltplan  ACHTUNG: C1 100nF fehlt am Print


Es handelt sich um einen ca. 10k NTC (Negativ Temperature Coeicient).
Bei einem negativen Temperaturbeiwert sinkt der Widerstandswert bei steigender Temperatur und umgekehrt.
Mit dem Trimmer kann eine Temperatur als Schwellwert eingestellt werden, bei dem der Komparator den Ausgang DO (Digital Out) auf 5,0V ändert.
LED1 leuchtet permanent,
LED2 leuchtet, wenn der Schwellwert erreicht wurde.


NTC 10k Ohm
-50°C  667,83k
-40°C  335,67k
-30°C  176,68k
-20°C    96,97k
-10°C    55,30k
     0°C  32,65k
+10°C  19,90k
+20°C  12,49k
+25°C  10,00k
+30°C  8,06k
+40°C  5,32k
+50°C  3,60k
+60°C  2,49k
+70°C  1,75k
+80°C  1,26k
+90°C     920 Ohm
+100°C   680 Ohm
+110°C   510 Ohm
+120°C   390 Ohm
+130°C   300 Ohm


Temperaturmodul „Digital Temp“ mit Heißleiter (NTC 10k).
Am Anschluss „DO“liegt ein Signal an, wenn die mit dem Potentiometer eingestellte Schalttemperatur erreicht ist.
Das analoge Signal kann an „AO“ abgegriffen werden.

Digital-Temperatur-Modul und eine digitale Schnittstelle, eingebaute 13 LED bauen eine einfache Schaltung, so dass die Temperatur-Warnleuchte 13 kommt mit digitalen Schnittstellen der LED, der digitale Temperaturfühler angeschlossen digitale drei Schnittstellen, wenn der digitale Temperatur-Sensor ein Tastensignal erfasst , LED leuchtet, sonst aus.


Beispielcode für ARDUINO UNO
Sketch KY-028

int Led = 13 ; // define LED Interface
int buttonpin = 3; // define the digital temperature sensor interface
int val ; // define numeric variables val
void setup ()
{
  pinMode (Led, OUTPUT) ; // define LED as output interface
  pinMode (buttonpin, INPUT) ; // define digital temperature 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 digital temperature sensor detects a signal, LED flashes
  {
    digitalWrite (Led, HIGH);
  }
  else
  {
    digitalWrite (Led, LOW);
  }
}

https://tkkrlab.nl/wiki/Arduino_KY-028_Temperature_sensor_module


Anschlussbelegung Arduino:


digitales Signal      =  pin-3
+Vcc                          =  5V
GND                         =  GND
analoges Signal    = pin-0

Funktionsweise des Sensors
Dieser Sensor besitzt auf seiner Platine drei funktionelle Bestandteile.
Die 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:

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 Sketch

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-028_Temperatur_Sensor_Modul_(Thermistor)

/* YourDuino.com Electronic Bricks Set - Analog-Digital All
See it here: http://yourduino.com/sunshop2/index.php?l=product_detail&p=364
Starter Example: Sketch Template
 - ELECTRONIC BRICK: The often-used Red brick with a 393 and both digital and analog outputs.
 - SEE the comments after "//" on each line below
 - CONNECTIONS:
   -
   -
 - V1.00 03/15/2015
   Questions: terry@yourduino.com */

/*-----( Import needed libraries )-----*/
//NONE YET
/*-----( Declare Constants and Pin Numbers )-----*/
#define LED_PIN 13          // define on-board LED 
#define DIGITAL_IN_PIN  3   // define the digital input pin
#define ANALOG_IN_PIN   A0  // define the analog input pin

/*-----( Declare objects )-----*/
//NONE YET

/*-----( Declare Variables )-----*/
int digitalValue ;  // read digital value
float sensorValue;  // read analoog value

void setup()   /****** SETUP: RUNS ONCE ******/
{
  pinMode (LED_PIN, OUTPUT) ;      // Onboard LED
  pinMode (DIGITAL_IN_PIN, INPUT) ;// digital input signal (Not actually required; INPUT is default)
  pinMode (ANALOG_IN_PIN, INPUT)  ;// analog  input signal (Not actually required; INPUT is default)
  Serial.begin(9600);              // Start the Serial Monitor connection
}//--(end setup )---


void loop()   /****** LOOP: RUNS CONSTANTLY ******/
{
  sensorValue = analogRead(ANALOG_IN_PIN);
  Serial.print("Analog value = ");
  Serial.print(sensorValue), DEC; // display analog value

  digitalValue = digitalRead (DIGITAL_IN_PIN) ;
  Serial.print("   Digital value = ");
  Serial.println(digitalValue), DEC; // display digital value  
  if (digitalValue == HIGH) // When the sensor value exceeds the set point, LED flashes
  {
    digitalWrite (LED_PIN, HIGH);
  }
  else
  {
    digitalWrite (LED_PIN, LOW);
  }
  delay(1000);

}//--(end main loop )---

/*-----( Declare User-written Functions )-----*/


//*********( THE END )***********



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.27   KY-029 - kleine 2-Farben-LED   (Dm 3mm)
Arduino KY-029
2-farbiges LED-Modul 3mm - Two-color LED mini 3mm

Ident mit

Arduino KY-011 2-farbiges LED Modul - Two-color LED 5mm
Anschlussbelegung Arduino:
LED Grün = [Pin 10]
LED Rot = [Pin 11]
Sensor GND = [Pin GND]

Stromaufnahme je Farbe: 20 mA
Spannung Rot: ca. 1,9 V
Spannung Grün: ca. 2,2 V


Arduino KY-029 Yin Yi 2-color LED module 3mm
Two-color 3mmLED hat eine gemeinsame Kathode (-Pol), verbunden mit dem „-“ Pin der Platine. Der mittlere Pin ist für Rot, der „S“ Pin ist für Grün.
Es sind keine verbauten Vorwiderstände auf dem Modul, geeignete externe Widerstände sind z.B. 220..330 Ohm.


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


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


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



Die 3 mm LED im difusen Gehäuse beinhaltet eine rote und eine grüne LED, die getrennt oder gleichzeitig angesteuert werden können, so dass sich auch eine Mischung aus Rot und Grün ergeben kann.
Der verbaute Widerstand ist mit 0R  lediglich eine überlüssige Drahtbrücke.
Für den Betrieb der LED müssen entsprechende Vorwiderstände extern eingeplant werden.




Inhalt

    
1 Magic Licht Cup-Modul
    
2 5mm rotes und grünes LED (gemeinsames Kathodenmodul)
    
3 Technische Daten
    
4 Beispielcode

Magic Licht Tasse-Modul
5mm rotes und grünes LED (allgemeines Kathode) Modul
Technische Daten

    
Farbe: Grün + Rot
    
Durchmesser: 5mm
    
Gehäusefarbe: Keine
    
Verpackung: Diffusion
    
Spannung (V): G: 2,3-2,6 Volt; R: 1,9-2, 2 V
    
Verwendung eines Stroms (MA): 20
    
Betrachtungswinkel: Wellenlänge (NM): 571 +625
    
Lichtstärke (MCD): 20-40; 60-80
    
Stent-Typ: langbeinig

Unsere Produkte sind weit verbreitet in elektronischen Wörterbuch, PDA, MP3, Kopfhörer, Digitalkameras, VCD, DVD, Car Audio, Kommunikation, Computer, Ladegeräte, Endstufe, Instrumentierung, Geschenke, elektronisches Spielzeug und Mobiltelefonen und vielen anderen Bereichen verwendet.
Beispielcode


Beispielcode für ARDUINO UNO
Sketch KY-029

// Arduino test code:
int redpin = 11; // select the pin for the red LED
int bluepin = 10; // select the pin for the blueLED
int val;
 
void setup () {
  pinMode (redpin, OUTPUT);
  pinMode (bluepin, OUTPUT);
  Serial.begin (9600);
}
 
void loop () {
 for(val=255;val>0;val--) {
   analogWrite (11, val);
   analogWrite (10, 255 - val);
   delay(5);
 }
 for(val=255;val<255;val++) {
    analogWrite (11, val);
    analogWrite (10, 255 - val);
   delay(5);
 }
}

https://tkkrlab.nl/wiki/Arduino_KY-029_Yin_Yi_2-color_LED_module_3MM



KY-029 2-Farben - Rot+Grün - 3mm LED Modul

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


Codebeispiel Arduino

Codebeispiel ON/OFF

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


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

KY-029_LED_ON-OFF.zip


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

Dieses wird im folgenden Codebeispiel gezeigt.

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


KY-029_PWM.zip

http://www.linkerkit.de/index.php?title=KY-029_2-Farben_-_Rot%2BGr%C3%BCn_-_3mm_LED_Modul







*********************************************************
https://learn.adafruit.com/photocells

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





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

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








Comments