User manual

ManualsBrandsJOY-IT ManualsRaspberry PiRaspberry Pi® 3 Model B 1 GB incl. PSU, incl. software

Summary of content (227 pages)

PAGE 2
Sehr geehrter Kunde, vielen Dank, dass Sie sich für unser Produkt entschieden haben. Dieses hochwertige Sensor Kit wurde speziell für die gängigsten Open-Source Plattformen in Deutschland entwickelt. Es ist zu folgenden Einplatinen Computern kompatibel: Raspberry Pi (alle Modelle), Arduino, Banana PI, Cubieboard, Cubietruck, Beaglebone, pcDuino und vielen weiteren Mikrocontroller-Systemen (Atmega, MicroChip PIC, STM32 usw.).
PAGE 3
Index Index Klicken Sie auf die Beschreibung des jeweiligen Sensors, um auf die entsprechende Unterseite zu gelangen KY-001 Temperatur Sensor Modul KY-002 Erschütterungs-Schalter Modul KY-003 Hall Magnetfeld-Sensor Modul KY-004 Taster-Modul Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 4
Index KY-005 Infrarot Transmitter Modul KY-006 Passives Piezo-Buzzer Modul KY-009 RGB LED SMD Modul KY-010 Lichtschranken-Modul KY-011 2-Farben [Rot+Grün] 5mm LED Modul Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 5
Index KY-012 Aktives Piezo-Buzzer Modul KY-013 Temperatur-Sensor Modul KY-015 Kombi-Sensor Temperatur+Feuchtigkeit KY-016 RGB 5mm LED Modul KY-017 Neigungsschalter Modul Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 6
Index KY-018 Fotowiderstand Modul KY-019 5V Relais Modul KY-020 Neigungs-Schalter Modul KY-021 Mini Magnet Reed Modul KY-022 Infrarot Receiver Modul KY-023 Joystick Modul (XY-Achsen) Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 7
Index KY-024 Linear magnetic Hall Sensor KY-025 Reed Modul KY-026 Flamen-Sensor Modul KY-027 Magic Light Cup Modul KY-028 Temperatur Sensor Modul (Thermistor) Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 8
Index KY-029 2-Farben [Rot+Grün] 3mm LED Modul KY-031 Klopf-Sensor Modul KY-032 Hindernis Detektor Modul KY-033 Tracking Sensor Modul KY-034 7 Farben LED Flash-Modul KY-035 Bihor Magnet Sensor Modul Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 9
Index KY-036 Metall-Touchsensor Modul KY-037 Mikrofon Sensor Modul [hohe Empfindlichkeit] KY-038 Mikrofon Sound Sensor Modul KY-039 Herzschlag Sensor Modul KY-040 Kodierter Drehschalter (Rotary Encoder) KY-050 Ultraschallabstandssensor Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 10
Index KY-051 Voltage Translator / Level Shifter KY-052 Drucksensor / Temperatursensor [BMP180] KY-053 Analog Digital Converter Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 11
KY-001 Temperatur Sensor Modul KY-001 Temperatur Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ....................................................................................
PAGE 12
KY-001 Temperatur Sensor Modul Pin-Belegung Codebeispiel Arduino Für das folgende Codebeispiel werden zwei zusätzliche Libraries benötigt: - [OneWire Library] von Paul Stoffregen | veröffentlicht unter der MIT License - [Dallas Temperature Control Library] von Miles Burton | veröffentlicht unter LGPL Beide Libraries sind im Paket enthalten und müssen vor dem Start der Arduino IDE in den "library"-Ordner kopiert werden.
PAGE 13
KY-001 Temperatur Sensor Modul } //Hauptprogrammschleife void loop() { // Temperaturmessung wird gestartet... sensors.requestTemperatures(); // ... und gemessene Temperatur ausgeben Serial.print("Temperatur: "); Serial.print(sensors.getTempCByIndex(0)); Serial.write(176); // UniCode-Angabe eines char-Symbols für das "°-Symbol" Serial.
PAGE 14
KY-001 Temperatur Sensor Modul # coding=utf-8 # Benoetigte Module werden importiert und eingerichtet import glob import time from time import sleep import RPi.GPIO as GPIO # An dieser Stelle kann die Pause zwischen den einzelnen Messungen eingestellt werden sleeptime = 1 # Der One-Wire EingangsPin wird deklariert und der integrierte #PullUp-Widerstand aktiviert GPIO.setmode(GPIO.BCM) GPIO.setup(4, GPIO.IN, pull_up_down=GPIO.
PAGE 15
KY-001 Temperatur Sensor Modul Anschlussbelegung Raspberry Pi: Signal = GPIO4 [Pin 7] +V = 3,3V [Pin 1] GND = Masse [Pin 6] Beispielprogramm Download KY-001_RPi_TemperaturSensor.zip Zu starten mit dem Befehl: sudo python KY-001_RPi_TemperaturSensor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 16
KY-002 Erschütterungs-Schalter Modul KY-002 Erschütterungs-Schalter Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ........................................................................
PAGE 17
KY-002 Erschütterungs-Schalter Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 18
KY-002 Erschütterungs-Schalter Modul Sensor +V = [Pin 5V] Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 19
KY-003 Hall Magnetfeld-Sensor Modul KY-003 Hall Magnetfeld-Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................................................
PAGE 20
KY-003 Hall Magnetfeld-Sensor Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 21
KY-003 Hall Magnetfeld-Sensor Modul Sensor +V = [Pin 5V] Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 22
KY-004 Taster-Modul KY-004 Taster-Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................................................................................
PAGE 23
KY-004 Taster-Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 24
KY-004 Taster-Modul Sensor +V = [Pin 5V] Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. #Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 25
KY-005 Infrarot Transmitter Modul KY-005 Infrarot Transmitter Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..............................................................................
PAGE 26
KY-005 Infrarot Transmitter Modul Vf= 1,1V If= 20mA emittierende Wellenlänge: 940nm (nicht sichtbares Licht) Vorwiderstände: Rf (3,3V) = 120Ω [z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie Raspberry-Pi] Rf (5V) = 220Ω [z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie Arduino] Pin-Belegung *Auf der Platine gibt es die Möglichkeit den jeweils benötigten Widerstand direkt aufzulöten.
PAGE 27
KY-005 Infrarot Transmitter Modul int Led = 13; void setup () { pinMode (Led, OUTPUT); // Initialisierung Ausgangspin für die LED } 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 zwei Sekunden in denen die LED dann ausgeschaltet ist } Beispielprogramm Download: LedTestArduino_4On_2Off.
PAGE 28
KY-005 Infrarot Transmitter Modul int RECV_PIN = 11; // Arduino-IRremote Library wird initialisiert IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Infrarot-Receiver wird gestartet } // Hauptprogrammschleife void loop() { // Es wird geprüft ob am Recveiver ein Signal eingegangen ist if (irrecv.decode(&results)) { // Bei Signaleingang wird das empfangene und dekodierte Signal // in der serriellen Konsole ausgegeben Serial.println(results.
PAGE 29
KY-005 Infrarot Transmitter Modul +V = [Pin 5V] GND = [Pin GND] Anschlussbelegung Arduino 2 [Sender]: KY-005 Signal = [Pin 3 (Arduino Uno) | Pin 9 (Arduino Mega)] GND+Widerstand = [Pin GND*] GND = [Pin GND] *Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist Codebeispiel Raspberry Pi Es sind zwei Anwendungsbeispiele für dieses Sensormodul hier vorgestellt.
PAGE 30
KY-005 Infrarot Transmitter Modul Sensor GND = Masse [Pin 6] *Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist Beispielprogramm Download LedTest_RPi_4On_2Off.zip Zu starten mit dem Befehl: sudo python LedTest_RPi_4On_2Off.py Codebeispiel Fernbedienung Der Raspberry Pi besitzt mit seiner fortschrittlichen Prozessorarchitektur den Vorteil gegenüber dem Arduino, dass dieser ein komplettes Linux-Betriebssystem betreiben kann.
PAGE 31
KY-005 Infrarot Transmitter Modul sudo apt-get install lirc -y [Hierzu muss der Raspberry Pi mit dem Internet verbunden sein] Damit das lirc Modul direkt zum Start des Betriebssystem verfügbar ist, müssen folgende Zeilen am Ende der Datei "/boot/config.txt" hinzugefügt werden: dtoverlay=lirc-rpi,gpio_in_pin=18,gpio_out_pin=17,gpio_in_pull=up Hierbei definiert "gpio_in_pin=18" den Eingangspin für den IR-Receiver, sowie "gpio_out_pin=17" den Ausgangspin für den IR-Transmitter.
PAGE 32
KY-005 Infrarot Transmitter Modul #Don't start lircmd even if there seems to be a good config file #START_LIRCMD=false #Don't start irexec, even if a good config file seems to exist. #START_IREXEC=false #Try to load appropriate kernel modules LOAD_MODULES=true # Run "lircd --driver=help" for a list of supported drivers.
PAGE 33
KY-005 Infrarot Transmitter Modul sudo /etc/init.d/lirc start ... kann der lirc-Dienst wieder gestartet werden. Fernbedienung anlernen Um eine Infrarot-Fernbedienung im lirc System zu registrieren, muss für die Fernbedienung die Datei "/etc /lirc/lircd.conf" konfiguriert werden. In dieser sind die jeweiligen Zuordnungen von Befehl zu empfangenen Infrarot-Codes gespeichert. Um eine entsprechend richtig formatierte lircd.
PAGE 34
KY-005 Infrarot Transmitter Modul name MeineFernbedienung geändert werden. Beachten Sie hierbei keine Leerzeichen und Sonderzeichen innerhalb des Namens zu verwenden. Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am unteren Ende, gespeichert und geschlossen werden. Nach erstellen der Konfigurationsdatei können Sie vorab für die original lircd.conf mit folgenden Befehl ein Backup erstellen: sudo mv /etc/lirc/lircd.conf /etc/lirc/lircd.conf.bak und mit dem Befehl...
PAGE 35
KY-005 Infrarot Transmitter Modul irsend SEND_ONCE MeineFernbedienung KEY_0 Auf dem Fernseher bzw. dem entsprechenden Empfänger-Endgerät, sollte sich nun eine Reaktion zeigen. Zu dem o.g. Befehl gibt es auch die Variation, dass das Signal wiederholend ausgegeben wird irsend SEND_START MeineFernbedienung KEY_0 Hier nach wird der gesendete Code [KEY_0] so oft wiederholt bis mit... irsend SEND_STOP MeineFernbedienung KEY_0 ...wieder beendet wird. Dies wird z.B.
PAGE 36
KY-006 Passives Piezo-Buzzer Modul KY-006 Passives Piezo-Buzzer Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ............................................................................
PAGE 37
KY-006 Passives Piezo-Buzzer Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches am Buzzer ein Alarmsignal mittels einer Rechteckspannung erzeugt. int buzzer = 8 ; // Deklaration des Buzzer-Ausgangspin void setup () { pinMode (buzzer, OUTPUT) ;// Initialisierung als Ausgangspin } void loop () { unsigned char i; while (1) { // In diesem Programm wird der Buzzer abwechselnd mit zwei verschiedenen // Frequenzen angesteuert.
PAGE 38
KY-006 Passives Piezo-Buzzer Modul delay (2) ; digitalWrite (buzzer, LOW) ; delay (2) ; } } } Anschlussbelegung Arduino: Sensor Signal = [Pin 8] Sensor - = [Pin GND] Beispielprogramm Download KY-006_Buzzer.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python Das Beispielprogramm nutzt Software-PWM, um am Ausgangspin eine Rechteckspannung mit definierbarer Frequenz zu erstellen.
PAGE 39
KY-006 Passives Piezo-Buzzer Modul GND = Masse [Pin 6] Beispielprogramm Download KY-006-RPI_PWM.zip Zu starten mit dem Befehl: sudo python KY-006-RPI_PWM.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 40
KY-009 RGB LED SMD Modul KY-009 RGB LED SMD Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ................................................................................................
PAGE 41
KY-009 RGB LED SMD Modul Rf (3,3V) [Grün]= 100Ω Rf (3,3V) [Rot]= 180Ω Rf (3,3V) [Blau]= 100Ω [z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie Raspberry-Pi] Rf (5V) [Grün] = 100Ω Rf (5V) [Rot] = 180Ω Rf (5V) [Blau] = 100Ω [z.B.
PAGE 42
KY-009 RGB LED SMD Modul } void loop () //Hauptprogrammschleife { digitalWrite (Led_Rot, HIGH); // LED wird eingeschaltet digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet digitalWrite (Led_Blau, 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 digitalWrite (Led_Blau, LOW); // LED wird eingeschaltet delay (3000); // Wartemodus für weitere drei Sekunden in denen d
PAGE 43
KY-009 RGB LED SMD Modul { analogWrite (Led_Blau, val); analogWrite (Led_Gruen, 255-val); analogWrite (Led_Rot, 128-val); delay (1); } } Beispielprogramm PWM Download: KY-009_PWM.zip Anschlussbelegung Arduino: LED Rot = [Pin 10] LED Grün = [Pin 11] LED Blau = [Pin 12] Sensor GND = [Pin GND] Codebeispiel Raspberry Pi Codebeispiel ON/OFF Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.
PAGE 44
KY-009 RGB LED SMD Modul time.sleep(3) #Wartemodus fuer 3 Sekunden # Aufraeumarbeiten nachdem das Programm beendet wurde except KeyboardInterrupt: GPIO.cleanup() Beispielprogramm ON/OFF Download KY009_RPi_ON-OFF.zip Zu starten mit dem Befehl: sudo python KY009_RPI_ON-OFF.
PAGE 45
KY-009 RGB LED SMD Modul ROT.ChangeDutyCycle(Rot) GRUEN.ChangeDutyCycle(Gruen) BLAU.ChangeDutyCycle(Blau) time.sleep(pause) ROT.ChangeDutyCycle(0) GRUEN.
PAGE 46
KY-010 Lichtschranken-Modul KY-010 Lichtschranken-Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................................................................
PAGE 47
KY-010 Lichtschranken-Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 48
KY-010 Lichtschranken-Modul Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino_inverted.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. #Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.IN, pull_up_down = GPIO.
PAGE 49
KY-011 2-Farben - Rot+Grün- 5mm LED Modul KY-011 2-Farben - Rot+Grün- 5mm LED Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..............................................................
PAGE 50
KY-011 2-Farben - Rot+Grün- 5mm LED Modul Rf (3,3V) [Grün]= 120Ω Rf (3,3V) [Rot]= 120Ω [z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie Raspberry-Pi] Rf (5V) [Grün] = 220Ω Rf (5V) [Rot] = 220Ω [z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie Arduino] Pin-Belegung 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.
PAGE 51
KY-011 2-Farben - Rot+Grün- 5mm LED Modul 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 } Beispielprogramm ON/OFF Download: KY-011_LED_ON-OFF.
PAGE 52
KY-011 2-Farben - Rot+Grün- 5mm LED Modul LED Grün = [Pin 10] LED Rot = [Pin 11] Sensor GND = [Pin GND] Codebeispiel Raspberry Pi Codebeispiel ON/OFF Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins abwechselnd, in 3 Sekunden Takt, angeschaltet werden können. # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind.
PAGE 53
KY-011 2-Farben - Rot+Grün- 5mm LED Modul 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. Im Raspberry Pi ist nur ein Hardware-PWM Channel uneingeschränkt auf die GPIO-Pins hinausgeführt, weswegen im vorliegenden Beispiel auf Software-PWM zurückgegriffen wird. # Benoetigte Module werden importiert und eingerichtet import random, time import RPi.
PAGE 54
KY-011 2-Farben - Rot+Grün- 5mm LED Modul Zu starten mit dem Befehl: sudo python KY011_RPI_PWM.py Anschlussbelegung Raspberry Pi: LED Gruen = GPIO4 [Pin 16] LED Rot = GPIO5 [Pin 18] Sensor GND = Masse [Pin 6] Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 55
KY-012 Aktives Piezo-Buzzer Modul KY-012 Aktives Piezo-Buzzer Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..............................................................................
PAGE 56
KY-012 Aktives Piezo-Buzzer Modul Pin-Belegung Codebeispiel Arduino Das aktive Buzzer-Modul benötigt, im Gegensatz zum passiven Modul (KY-006) keine Rechteckspannung um einen Ton zu erzeugen - wird an seinem Signal-Pin eine Spannung von min. 3,3V angelegt, so wird im Buzzer die benötigte Rechteckspannung selbstständig erzeugt. Dieses Codebeispiel zeigt auf, wie der Buzzer mittels eines definierbaren Ausgangspins abwechselnd für Vier Sekunden ein- und danach zwei Sekunden ausgeschaltet werden kann.
PAGE 57
KY-012 Aktives Piezo-Buzzer Modul Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python Das aktive Buzzer-Modul benötigt, im Gegensatz zum passiven Modul (KY-006) keine Rechteckspannung um einen Ton zu erzeugen - wird an seinem Signal-Pin eine Spannung von min. 3,3V angelegt, so wird im Buzzer die benötigte Rechteckspannung selbstständig erzeugt.
PAGE 58
KY-013 Temperatur-Sensor Modul KY-013 Temperatur-Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ....................................................................................
PAGE 59
KY-013 Temperatur-Sensor Modul Diese Änderung des Widerstands lässt sich mathematisch annähern und in einen linearen Verlauf umrechnen und den Temperaturkoeffizienten (Abhängigkeit von Widerstandsänderung zur Temperaturänderung) bestimmen. Mittels diesen lässt sich somit dann immer die aktuelle Temperatur errechnen, wenn man den aktuellen Widerstand kennt.
PAGE 60
KY-013 Temperatur-Sensor Modul Pin-Belegung Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 61
KY-013 Temperatur-Sensor Modul Codebeispiel Arduino Das Programm misst den aktuellen Spannungswert am NTC, berechnet die Temperatur und übersetzt das Ergebnis in °C für die serielle Ausgabe #include int sensorPin = A5; // Hier wird der Eingangs-Pin deklariert // Diese Funktion übersetzt den aufgenommenen analogen Messwert // in die entsprechende Temperatur in °C und gibt diesen aus double Thermistor(int RawADC) { double Temp = Temp = Temp = return Temp; log(10000.0 * ((1024.
PAGE 62
KY-013 Temperatur-Sensor Modul Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 63
KY-013 Temperatur-Sensor Modul ADS1015 = 0x00 ADS1115 = 0x01 # Verstaerkung gain = 4096 # # gain = 2048 # gain = 1024 # gain = 512 # gain = 256 # 12-bit ADC # 16-bit (Gain) wird ausgewaehlt +/- 4.096V # +/- 2.048V # +/- 1.024V # +/- 0.512V # +/- 0.
PAGE 64
KY-013 Temperatur-Sensor Modul analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 17] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download KY-013_RPi_TemperaturSensor.zip Zu starten mit dem Befehl: sudo python KY-013_RPi_TemperaturSensor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 65
KY-015 Kombi-Sensor Temperatur+Feuchtigkeit KY-015 Kombi-Sensor Temperatur+Feuchtigkeit Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................................
PAGE 66
KY-015 Kombi-Sensor Temperatur+Feuchtigkeit Pin-Belegung Software-Beispiel Arduino Dieser Sensor gibt sein Messergebnis nicht als analoges Signal auf einen Ausgangspin aus, sondern kommuniziert diesen digital kodiert. Zur Ansteuerung dieses Sensormoduls gibt es mehrere Möglichkeiten - als besonders zugänglich hat sich die Adafruit_DHT Library erwiesen, die die Firma Adafruit unter dem folgenden Link unter der OpenSource MITLizenz veröffentlicht hat.
PAGE 67
KY-015 Kombi-Sensor Temperatur+Feuchtigkeit // Zwischen den Messungen wird eine Pause von 2 Sekunden eingelegt, // damit beim nächsten Druchlauf eine neue Messung erfasst werden kann. void loop() { // Zwei Sekunden Pause zwischen den Messungen delay(2000); // Luftfeuchtigkeit wird gemessen float h = dht.readHumidity(); // Temperatur wird gemessen float t = dht.
PAGE 68
KY-015 Kombi-Sensor Temperatur+Feuchtigkeit git clone https://github.com/adafruit/Adafruit_Python_DHT.git ... kann die aktuelle Version der Adafruit_BM085 Library heruntergeladen und entpackt werden Danach wechseln wir mit... cd Adafruit_Python_BMP/ ... in den heruntergeladenen Ordner und intallieren mit... sudo python setup.py install ... die Library. Hiernach kann die Library genutzt werden.
PAGE 69
KY-015 Kombi-Sensor Temperatur+Feuchtigkeit # Hier kann der Pin deklariert werden, an dem das Sensormodul angeschlossen ist GPIO_Pin = 23 print('KY-015 Sensortest - Temperatur und Luftfeuchtigkeit') try: while(1): # Messung wird gestartet und das Ergebnis in die entsprechenden Variablen geschrieben Luftfeuchte, Temperatur = Adafruit_DHT.
PAGE 70
KY-016 RGB 5mm LED Modul KY-016 RGB 5mm LED Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ................................................................................................
PAGE 71
KY-016 RGB 5mm LED Modul Rf (3,3V) [Grün]= 100Ω Rf (3,3V) [Rot]= 180Ω Rf (3,3V) [Blau]= 100Ω [z.B. beim Einsatz mit ARM CPU-Kern basierten Mikrokontrollern wie Raspberry-Pi] Rf (5V) [Grün] = 100Ω Rf (5V) [Rot] = 180Ω Rf (5V) [Blau] = 100Ω [z.B.
PAGE 72
KY-016 RGB 5mm LED Modul digitalWrite (Led_Gruen, LOW); // LED wird eingeschaltet digitalWrite (Led_Blau, 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 digitalWrite (Led_Blau, LOW); // LED wird eingeschaltet delay (3000); // Wartemodus für weitere drei Sekunden in denen die LEDs dann umgeschaltet werden digitalWrite (Led_Rot, LOW); // LED wird eingeschaltet digitalWri
PAGE 73
KY-016 RGB 5mm LED Modul analogWrite (Led_Blau, val); analogWrite (Led_Gruen, 255-val); analogWrite (Led_Rot, 128-val); delay (1); } } Beispielprogramm PWM Download: KY-016_PWM.zip Anschlussbelegung Arduino: LED Rot = [Pin 10] LED Grün = [Pin 11] LED Blau = [Pin 12] Sensor GND = [Pin GND] Codebeispiel Raspberry Pi Codebeispiel ON/OFF Dieses Codebeispiel zeigt auf, wie die integrierten LEDs mittels eines definierbaren Ausgangspins abwechselnd, in 3 Sekunden Takt, angeschaltet werden können.
PAGE 74
KY-016 RGB 5mm LED Modul time.sleep(3) #Wartemodus fuer 3 Sekunden # Aufraeumarbeiten nachdem das Programm beendet wurde except KeyboardInterrupt: GPIO.cleanup() Beispielprogramm ON/OFF Download Zu starten mit dem Befehl: sudo python KY016_RPI_ON-OFF.
PAGE 75
KY-016 RGB 5mm LED Modul GRUEN.ChangeDutyCycle(Gruen) BLAU.ChangeDutyCycle(Blau) time.sleep(pause) ROT.ChangeDutyCycle(0) GRUEN.
PAGE 76
KY-017 Neigungsschalter Modul KY-017 Neigungsschalter Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ......................................................................................
PAGE 77
KY-017 Neigungsschalter Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 78
KY-017 Neigungsschalter Modul Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino_withoutPullUP.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 79
KY-018 Fotowiderstand Modul KY-018 Fotowiderstand Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................................................................
PAGE 80
KY-018 Fotowiderstand Modul Pin-Belegung Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 81
KY-018 Fotowiderstand Modul 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.
PAGE 82
KY-018 Fotowiderstand Modul Um diese Problematik zu umgehen, besitzt unser Sensorkit X40 mit dem KY-053 ein Modul mit 16 Bit genauen ADC, welches Sie am Raspberry nutzen können, um diesen um 4 analoge Eingänge erweitern zu können. Dieses wird per I2C an den Raspberry Pi angeschlossen, übernimmt die analoge Messung und gibt den Wert digital an den Raspberry Pi weiter. Somit empfehlen wir, bei analogen Sensoren dieses Sets das KY-053 Modul mit dem besagten ADC dazwischenzuschalten.
PAGE 83
KY-018 Fotowiderstand Modul # gain = 256 # +/- 0.
PAGE 84
KY-018 Fotowiderstand Modul SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_Single_Analog_Sensor.zip Zu starten mit dem Befehl: sudo python RPi_Single_Analog_Sensor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 85
KY-019 5V Relais Modul KY-019 5V Relais Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ....................................................................................................
PAGE 86
KY-019 5V Relais Modul Die Ausgangsleiste des Relais besitzt zwei Ausgangsterminals: - Das eine welches mit "NC" für "normally closed" gekennzeichnet ist, was bedeutet dass dieser Durchgang ohne elektrische Umschaltung am Relais standardmäßig kurzgeschlossen ist. - Das andere welches mit "NO" für "normally open" gekennzeichnet ist, was bedeutet dass dieser Durchgang ohne elektrische Umschaltung am Relais standardmäßig offen bzw. getrennt ist.
PAGE 87
KY-019 5V Relais Modul int relay = 10; // Hier wird der Pin deklariert, an dem das Relay angeschlossen ist delayTime = 1 // Wert in Sekunden, wie lange zwischen den Umschaltungen gewartet werden soll void setup () { pinMode (relay, OUTPUT); // Der Pin wird als Ausgang deklariert } // Das Programm bildet einen Blinker nach - es schaltet das Relais in vorher definierter // Zeit (delayTime) zwischen den beiden Zuständen (bzw. Ausgangsterminals) um.
PAGE 88
KY-019 5V Relais Modul # Aufraeumarbeiten nachdem das Programm beendet wurde except KeyboardInterrupt: GPIO.cleanup() Anschlussbelegung Raspberry Pi: Relais - = GND [Pin 06] Relais + = 5V [Pin 2] Relais Signal = GPIO24 [Pin 18] Beispielprogramm Download KY-019_RPi_Relais.zip Zu starten mit dem Befehl: sudo python KY-019_RPi_Relais.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 89
KY-020 Neigungs-Schalter Modul KY-020 Neigungs-Schalter Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ....................................................................................
PAGE 90
KY-020 Neigungs-Schalter Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 91
KY-020 Neigungs-Schalter Modul Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino_withoutPullUP.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 92
KY-021 Mini Magnet Reed Modul KY-021 Mini Magnet Reed Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ......................................................................................
PAGE 93
KY-021 Mini Magnet Reed Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 94
KY-021 Mini Magnet Reed Modul Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino_withoutPullUP.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 95
KY-022 Infrarot Receiver Modul KY-022 Infrarot Receiver Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ....................................................................................
PAGE 96
KY-022 Infrarot Receiver Modul Pin-Belegung Codebeispiel Arduino Mithilfe der beiden Sensormodule KY-005 und KY-022 lässt sich ein Infrarot-Fernbedienung + Infrarot Receiver System aufbauen. Hierzu werden neben den zwei Modulen auch zwei einzelne Arduinos benötigt. Der eine fungiert hierbei dann als Sender und der andere empfängt die Signale und gibt diese dann in der seriellen Konsole aus.
PAGE 97
KY-022 Infrarot Receiver Modul // des KY-022 deklariert werden int RECV_PIN = 11; // Arduino-IRremote Library wird initialisiert IRrecv irrecv(RECV_PIN); decode_results results; void setup() { Serial.begin(9600); irrecv.enableIRIn(); // Infrarot-Receiver wird gestartet } // Hauptprogrammschleife void loop() { // Es wird geprüft ob am Recveiver ein Signal eingegangen ist if (irrecv.
PAGE 98
KY-022 Infrarot Receiver Modul Signal = [Pin 11] +V = [Pin 5V] GND = [Pin GND] Anschlussbelegung Arduino 2 [Sender]: KY-005 Signal = [Pin 3 (Arduino Uno) | Pin 9 (Arduino Mega)] GND+Widerstand = [Pin GND*] GND = [Pin GND] *Nur wenn Vorwiderstand auf dem Modul verlötet wurde und nicht vor dem Modul geschaltet ist Codebeispiel Raspberry Pi Der Raspberry Pi besitzt mit seiner fortschrittlichen Prozessorarchitektur den Vorteil gegenüber dem Arduino, dass dieser ein komplettes Linux-Betriebssystem b
PAGE 99
KY-022 Infrarot Receiver Modul Lirc Installation Als erstes öffnen wir auf dem Desktop ein Terminal oder verbinden wir uns per SSH mit dem Raspberry Pi. Dort geben Sie den folgenden Befehl ein, um lirc auf den Raspberry Pi zu installieren: sudo apt-get install lirc -y [Hierzu muss der Raspberry Pi mit dem Internet verbunden sein] Damit das lirc Modul direkt zum Start des Betriebssystem verfügbar ist, müssen folgende Zeilen am Ende der Datei "/boot/config.
PAGE 100
KY-022 Infrarot Receiver Modul # /etc/lirc/hardware.conf # # Arguments which will be used when launching lircd LIRCD_ARGS="" #Don't start lircmd even if there seems to be a good config file #START_LIRCMD=false #Don't start irexec, even if a good config file seems to exist. #START_IREXEC=false #Try to load appropriate kernel modules LOAD_MODULES=true # Run "lircd --driver=help" for a list of supported drivers.
PAGE 101
KY-022 Infrarot Receiver Modul pulse space pulse space pulse ... 603 95239 9020 2208 603 Mit dem Befehl... sudo /etc/init.d/lirc start ... kann der lirc-Dienst wieder gestartet werden. Fernbedienung anlernen Um eine Infrarot-Fernbedienung im lirc System zu registrieren, muss für die Fernbedienung die Datei "/etc /lirc/lircd.conf" konfiguriert werden. In dieser sind die jeweiligen Zuordnungen von Befehl zu empfangenen Infrarot-Codes gespeichert. Um eine entsprechend richtig formatierte lircd.
PAGE 102
KY-022 Infrarot Receiver Modul Hier kann dann die Zeile 17 von name /home/pi/MeineFernbedienung.conf in name MeineFernbedienung geändert werden. Beachten Sie hierbei keine Leerzeichen und Sonderzeichen innerhalb des Namens zu verwenden. Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am unteren Ende, gespeichert und geschlossen werden. Nach erstellen der Konfigurationsdatei können Sie vorab für die original lircd.
PAGE 103
KY-022 Infrarot Receiver Modul irsend LIST MeineFernbedienung "" ...welche Zuordnungen für die jeweilige gespeicherte Fernbedienung verfügbar sind. Nun können wir z.B. den Befehl [KEY_0] versenden, indem wir den folgenden Befehl verwenden: irsend SEND_ONCE MeineFernbedienung KEY_0 Auf dem Fernseher bzw. dem entsprechenden Empfänger-Endgerät, sollte sich nun eine Reaktion zeigen. Zu dem o.g.
PAGE 104
KY-023 Joystick Modul (XY-Achsen) KY-023 Joystick Modul (XY-Achsen) Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..............................................................................
PAGE 105
KY-023 Joystick Modul (XY-Achsen) Im Ruhezustand befindet sich der Mitte, so dass Widerstand1 auch die angelegte Spannung beide verteilt - z.B Messwert B Wird jetzt die Position von der verändert, so ändern sich die j abhängig zur aktuellen Positio eine Richtung so wird Widersta Widerstand 2 größer, geht es i so wird dann Widerstand 1 grö kleiner. Je nachdem wie sich die Wider aufteilen, resultiert dieses in e Spannungswert, den man zwis Widerständen (beim Potentiom messen und somit die Position kann.
PAGE 106
KY-023 Joystick Modul (XY-Achsen) Pin-Belegung Codebeispiel Arduino Das Programm liest die aktuellen Werte der Eingang-Pins, konvertiert diese in eine Spannung (0-1023 -> 0V5V) und gibt diese auf der seriellen Ausgabe aus.
PAGE 107
KY-023 Joystick Modul (XY-Achsen) //... und an Serial.print Serial.print Serial.print dieser Stelle ausgegeben ("X-Achse:"); Serial.print (x, 4); ("Y-Achse:"); Serial.print (y, 4); ("Knopf:"); Serial.print ("V, "); Serial.print ("V, "); if(Knopf==1) { Serial.println (" nicht gedrueckt"); } else { Serial.
PAGE 108
KY-023 Joystick Modul (XY-Achsen) Das Programm liest die aktuellen Werte der Eingang-Pins und gibt diese in der Konsole als Wert in [mV] aus. # #!/usr/bin/python # coding=utf-8 #################################################################################################### ### Copyright by Joy-IT ### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.
PAGE 109
KY-023 Joystick Modul (XY-Achsen) # # # # # ######## Hauptprogrammschleife ######## Das Programm liest die aktuellen Werte der Eingang-Pins und gibt diese in der Konsole aus try: while True: #Aktuelle Werte werden aufgenommen x = adc.readADCSingleEnded(x_adc_channel, y = adc.readADCSingleEnded(y_adc_channel, gain, gain, sps) sps) # Ausgabe auf die Konsole if GPIO.
PAGE 110
KY-024 Linear magnetic Hall Sensor KY-024 Linear magnetic Hall Sensor Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ............................................................................
PAGE 111
KY-024 Linear magnetic Hall Sensor LED2: Zeigt an, dass ein Magnetfeld detektiert wurde Pin-Belegung 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.
PAGE 112
KY-024 Linear magnetic Hall Sensor 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.
PAGE 113
KY-024 Linear magnetic Hall Sensor // 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.
PAGE 114
KY-024 Linear magnetic Hall Sensor Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 115
KY-024 Linear magnetic Hall Sensor ADS1015 = 0x00 ADS1115 = 0x01 # Verstaerkung gain = 4096 # # gain = 2048 # gain = 1024 # gain = 512 # gain = 256 # 12-bit ADC # 16-bit (Gain) wird ausgewaehlt +/- 4.096V # +/- 2.048V # +/- 1.024V # +/- 0.512V # +/- 0.
PAGE 116
KY-024 Linear magnetic Hall Sensor digitales Signal = GPIO 24 [Pin 18 (RPi)] +V = 3,3V [Pin 1 (RPi)] GND = Masse [Pin 06 (RPi)] analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 01] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_AnalogSensor.zip Zu starten mit dem Befehl: sudo python RPi_AnalogSensor.py Ausgabe: 29.04.
PAGE 117
KY-025 Reed Modul KY-025 Reed Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..............................................................................................................
PAGE 118
KY-025 Reed Modul 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 Pin-Belegung Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 119
KY-025 Reed Modul 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.
PAGE 120
KY-025 Reed Modul 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.
PAGE 121
KY-025 Reed Modul Anschlussbelegung Arduino: digitales Signal = [Pin 3] +V = [Pin 5V] GND = [Pin GND] analoges Signal = [Pin 0] Beispielprogramm Download Ard_Analoger_Sensor.zip Codebeispiel Raspberry Pi !! Achtung !! Analoger Sensor !! Achtung !! Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 122
KY-025 Reed Modul # Dieser Code nutzt die ADS1115 und die I2C Python Library fuer den Raspberry Pi # Diese ist unter folgendem Link unter der BSD Lizenz veroeffentlicht # [https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code] from Adafruit_ADS1x15 import ADS1x15 from time import sleep # Weitere benoetigte Module werden importiert und eingerichtet import time, signal, sys, os import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.
PAGE 123
KY-025 Reed Modul print "Analoger Spannungswert:" analog,"mV,","Grenzwert: noch nicht erreicht" else: print "Analoger Spannungswert:", analog, "mV, ", "Grenzwert: erreicht" print "---------------------------------------" # Reset + Delay button_pressed = False time.sleep(delayTime) except KeyboardInterrupt: GPIO.
PAGE 124
KY-026 Flamen-Sensor Modul KY-026 Flamen-Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ............................................................................................
PAGE 125
KY-026 Flamen-Sensor Modul Pin-Belegung 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.
PAGE 126
KY-026 Flamen-Sensor Modul 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.
PAGE 127
KY-026 Flamen-Sensor Modul // 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.
PAGE 128
KY-026 Flamen-Sensor Modul Um diese Problematik zu umgehen, besitzt unser Sensorkit X40 mit dem KY-053 ein Modul mit 16 Bit genauen ADC, welches Sie am Raspberry nutzen können, um diesen um 4 analoge Eingänge erweitern zu können. Dieses wird per I2C an den Raspberry Pi angeschlossen, übernimmt die analoge Messung und gibt den Wert digital an den Raspberry Pi weiter. Somit empfehlen wir, bei analogen Sensoren dieses Sets das KY-053 Modul mit dem besagten ADC dazwischenzuschalten.
PAGE 129
KY-026 Flamen-Sensor Modul # Abtasterate des ADC (SampleRate) wird ausgewaehlt # sps = 8 # 8 Samples pro Sekunde # sps = 16 # 16 Samples pro Sekunde # sps = 32 # 32 Samples pro Sekunde sps = 64 # 64 Samples pro Sekunde # sps = 128 # 128 Samples pro Sekunde # sps = 250 # 250 Samples pro Sekunde # sps = 475 # 475 Samples pro Sekunde # sps = 860 # 860 Samples pro Sekunde # ADC-Channel adc_channel = # adc_channel # adc_channel # adc_channel (1-4) wird ausgewaehlt 0 # Channel 0 = 1 # Channel 1 = 2 # Channel 2 =
PAGE 130
KY-026 Flamen-Sensor Modul VDD = 3,3V [Pin 01] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_AnalogSensor.zip Zu starten mit dem Befehl: sudo python RPi_AnalogSensor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 131
KY-027 Magic Light Cup Modul KY-027 Magic Light Cup Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ........................................................................................
PAGE 132
KY-027 Magic Light Cup Modul Rf (5V) [Rot] = 220Ω [z.B. beim Einsatz mit Atmel Atmega basierten Mikrokontrollern wie Arduino] Pin-Belegung 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.
PAGE 133
KY-027 Magic Light Cup Modul LED - = [Pin GND] Sensor Signal = [Pin 10] Sensor +V = [Pin 5V] Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python In diesem Programmbeispiel Leuchtet die LED auf, wenn am Neigungsschalter, ein Signal detektiert wird. # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.
PAGE 134
KY-027 Magic Light Cup Modul Zu starten mit dem Befehl: sudo python KY-027-RPi-MagicLightCup.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 135
KY-028 Temperatur Sensor Modul (Thermistor) KY-028 Temperatur Sensor Modul (Thermistor) Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................................
PAGE 136
KY-028 Temperatur Sensor Modul (Thermistor) Pin-Belegung 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.
PAGE 137
KY-028 Temperatur Sensor Modul (Thermistor) 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.
PAGE 138
KY-028 Temperatur Sensor Modul (Thermistor) // 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.
PAGE 139
KY-028 Temperatur Sensor Modul (Thermistor) Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 140
KY-028 Temperatur Sensor Modul (Thermistor) ADS1015 = 0x00 ADS1115 = 0x01 # Verstaerkung gain = 4096 # # gain = 2048 # gain = 1024 # gain = 512 # gain = 256 # 12-bit ADC # 16-bit (Gain) wird ausgewaehlt +/- 4.096V # +/- 2.048V # +/- 1.024V # +/- 0.512V # +/- 0.
PAGE 141
KY-028 Temperatur Sensor Modul (Thermistor) digitales Signal = GPIO 24 [Pin 18 (RPi)] +V = 3,3V [Pin 1 (RPi)] GND = Masse [Pin 06 (RPi)] analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 01] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_AnalogSensor.zip Zu starten mit dem Befehl: sudo python RPi_AnalogSensor.py Ausgabe: 29.04.
PAGE 142
KY-029 2-Farben - Rot+Grün - 3mm LED Modul KY-029 2-Farben - Rot+Grün - 3mm LED Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ............................................................
PAGE 143
KY-029 2-Farben - Rot+Grün - 3mm LED Modul Pin-Belegung 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.
PAGE 144
KY-029 2-Farben - Rot+Grün - 3mm LED Modul 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.
PAGE 145
KY-029 2-Farben - Rot+Grün - 3mm LED Modul # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier werden die Ausgangs-Pin deklariert, an dem die LEDs angeschlossen sind. LED_ROT = 5 LED_GRUEN = 4 GPIO.setup(LED_ROT, GPIO.OUT, initial= GPIO.LOW) GPIO.setup(LED_GRUEN, GPIO.OUT, initial= GPIO.LOW) print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]" # Hauptprogrammschleife try: while True: print("LED ROT 3 Sekunden an") GPIO.
PAGE 146
KY-029 2-Farben - Rot+Grün - 3mm LED Modul LED_Gruen = 4 # Set pins to output mode GPIO.setup(LED_Rot, GPIO.OUT) GPIO.setup(LED_Gruen, GPIO.OUT) Freq = 100 #Hz # Die jeweiligen Farben werden initialisiert. ROT = GPIO.PWM(LED_Rot, Freq) GRUEN = GPIO.PWM(LED_Gruen, Freq) ROT.start(0) GRUEN.start(0) # # # # Diese Funktion generiert die eigentliche Farbe Mittels der jeweiligen Farbvariable, kann die Farbintensitaet geaendert werden Nachdem die Farbe eingestellt wurde, wird mittels "time.
PAGE 147
KY-031 Klopf-Sensor Modul KY-031 Klopf-Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..............................................................................................
PAGE 148
KY-031 Klopf-Sensor Modul Pin-Belegung Codebeispiel Arduino Hier bei handelt es sich um ein Beispielprogramm, welches eine LED zum Leuchten bringt, wenn am Sensor ein Signal detektiert wurde. Als LED können z.B. auch unter anderem die Module KY-011, KY-016 oder KY029 verwendet werden.
PAGE 149
KY-031 Klopf-Sensor Modul Sensor - = [Pin GND] Beispielprogramm Download SensorTest_Arduino_withoutPullUP.zip Codebeispiel Raspberry Pi Programmierbeispiel in der Programmiersprache Python # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 150
KY-032 Hindernis Detektor Modul KY-032 Hindernis Detektor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..................................................................................
PAGE 151
KY-032 Hindernis Detektor Modul Zustand 1: Detektor hat Hindernis erkannt [LED auf dem Modul: Ein] [Sensor Signal= Digital Aus] Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 152
KY-032 Hindernis Detektor Modul Dieser Sensor besitzt mit dem zusätzlichen Pin "Enable" die Möglichkeit die Hindernis-Detektion mittels Kontroller zu aktivieren oder zu deaktivieren. Standardmäßig ist bei diesem Sensor dieses aktiviert, also dauerhaft wird die Detektion durchgeführt - möchte man dies nicht, da die gewünschte Programmierung z.B. nicht vorsieht, so muss man die Steckbrücke (siehe grün im Bild) mit der Beschriftung "EN" entfernen und auf den "Enable-Pin" ein Steuersignal aktivieren.
PAGE 153
KY-032 Hindernis Detektor Modul { Serial.println("Kein Hindernis"); } else { Serial.println("Hindernis erkannt"); } Serial.println("------------------------------------"); delay(500); // Pause zwischen der Messung von 500ms } Anschlussbelegung Arduino: Sensor Enable = [N.C. (Steckbrücke gesteckt)] Sensor Signal = [Pin 10] Sensor +V = [Pin 5V] Sensor GND = [Pin GND] Beispielprogramm Download KY-032_HindernisDetektor.
PAGE 154
KY-032 Hindernis Detektor Modul Anschlussbelegung Raspberry Pi: Enable = - [N.C. (Steckbrücke gesteckt)] Signal = GPIO24 [Pin 18] +V = 3,3V [Pin 1] GND = Masse [Pin 6] Beispielprogramm Download KY-032_RPi_HindernisDetektor.zip Zu starten mit dem Befehl: sudo python KY-032_RPi_HindernisDetektor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 155
KY-033 Tracking Sensor Modul KY-033 Tracking Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ........................................................................................
PAGE 156
KY-033 Tracking Sensor Modul Zustand 2: Line Tracker ist außerhalb einer Line (reflektierenden Fläche) [LED auf dem Modul: AN] [Sensor Signal= Digital Aus] Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 157
KY-033 Tracking Sensor Modul Pin-Belegung 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.
PAGE 158
KY-033 Tracking Sensor Modul Beispielprogramm Download KY-033_TrackingSensor.zip Codebeispiel Raspberry Pi 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 # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. GPIO_PIN = 24 GPIO.setup(GPIO_PIN, GPIO.
PAGE 159
KY-034 7 Farben LED Flash-Modul KY-034 7 Farben LED Flash-Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..................................................................................
PAGE 160
KY-034 7 Farben LED Flash-Modul Pin-Belegung Codebeispiel Arduino Diese Codebeispiel zeigt auf, wie eine LED mittels eines definierbaren Ausgangspins abwechselnd für Vier Sekunden ein- und danach zwei Sekunden ausgeschaltet werden kann.
PAGE 161
KY-034 7 Farben LED Flash-Modul # Benoetigte Module werden importiert und eingerichtet import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) # Hier wird der Eingangs-Pin deklariert, an dem der Sensor angeschlossen ist. # Zusaetzlich wird auch der PullUP Widerstand am Eingang aktiviert LED_PIN = 24 GPIO.setup(LED_PIN, GPIO.OUT, initial= GPIO.LOW) print "LED-Test [druecken Sie STRG+C, um den Test zu beenden]" # Hauptprogrammschleife try: while True: print("LED 4 Sekunden an") GPIO.output(LED_PIN,GPIO.
PAGE 162
KY-035 Bihor Magnet Sensor Modul KY-035 Bihor Magnet Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ................................................................................
PAGE 163
KY-035 Bihor Magnet Sensor Modul Pin-Belegung 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.
PAGE 164
KY-035 Bihor Magnet Sensor Modul Sensor +V = [Pin 5V] Sensor Signal = [Pin A5] Beispielprogramm Download Single_Analog_Sensor.zip Codebeispiel Raspberry Pi !! Achtung !! Analoger Sensor !! Achtung !! Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 165
KY-035 Bihor Magnet Sensor Modul from time import sleep # Weitere benoetigte Module werden importiert und eingerichtet import time, signal, sys, os, math import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) # Benutzte Variablen werden initialisiert delayTime = 0.
PAGE 166
KY-035 Bihor Magnet Sensor Modul except KeyboardInterrupt: GPIO.cleanup() Anschlussbelegung Raspberry Pi: Sensor GND = GND [Pin 06 (RPi)] +V = 3,3V [Pin 01 (RPi)] analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 17] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_Single_Analog_Sensor.
PAGE 167
KY-036 Metall-Touchsensor Modul KY-036 Metall-Touchsensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..................................................................................
PAGE 168
KY-036 Metall-Touchsensor Modul Pin-Belegung 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.
PAGE 169
KY-036 Metall-Touchsensor Modul 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.
PAGE 170
KY-036 Metall-Touchsensor Modul // 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.
PAGE 171
KY-036 Metall-Touchsensor Modul Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 172
KY-036 Metall-Touchsensor Modul ADS1015 = 0x00 ADS1115 = 0x01 # Verstaerkung gain = 4096 # # gain = 2048 # gain = 1024 # gain = 512 # gain = 256 # 12-bit ADC # 16-bit (Gain) wird ausgewaehlt +/- 4.096V # +/- 2.048V # +/- 1.024V # +/- 0.512V # +/- 0.
PAGE 173
KY-036 Metall-Touchsensor Modul digitales Signal = GPIO 24 [Pin 18 (RPi)] +V = 3,3V [Pin 1 (RPi)] GND = Masse [Pin 06 (RPi)] analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 01] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_AnalogSensor.zip Zu starten mit dem Befehl: sudo python RPi_AnalogSensor.py Ausgabe: 29.04.
PAGE 174
KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..........................................
PAGE 175
KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit Pin-Belegung 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.
PAGE 176
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.
PAGE 177
KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit // 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.
PAGE 178
KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 179
KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit ADS1015 = 0x00 ADS1115 = 0x01 # Verstaerkung gain = 4096 # # gain = 2048 # gain = 1024 # gain = 512 # gain = 256 # 12-bit ADC # 16-bit (Gain) wird ausgewaehlt +/- 4.096V # +/- 2.048V # +/- 1.024V # +/- 0.512V # +/- 0.
PAGE 180
KY-037 Mikrofon Sensor Modul - hohe Empfindlichkeit digitales Signal = GPIO 24 [Pin 18 (RPi)] +V = 3,3V [Pin 1 (RPi)] GND = Masse [Pin 06 (RPi)] analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 01] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_AnalogSensor.zip Zu starten mit dem Befehl: sudo python RPi_AnalogSensor.py Ausgabe: 29.04.
PAGE 181
KY-038 Mikrofon Sound Sensor Modul KY-038 Mikrofon Sound Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ............................................................................
PAGE 182
KY-038 Mikrofon Sound Sensor Modul Pin-Belegung 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.
PAGE 183
KY-038 Mikrofon Sound Sensor Modul 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.
PAGE 184
KY-038 Mikrofon Sound Sensor Modul // 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.
PAGE 185
KY-038 Mikrofon Sound Sensor Modul Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 186
KY-038 Mikrofon Sound Sensor Modul ADS1015 = 0x00 ADS1115 = 0x01 # Verstaerkung gain = 4096 # # gain = 2048 # gain = 1024 # gain = 512 # gain = 256 # 12-bit ADC # 16-bit (Gain) wird ausgewaehlt +/- 4.096V # +/- 2.048V # +/- 1.024V # +/- 0.512V # +/- 0.
PAGE 187
KY-038 Mikrofon Sound Sensor Modul digitales Signal = GPIO 24 [Pin 18 (RPi)] +V = 3,3V [Pin 1 (RPi)] GND = Masse [Pin 06 (RPi)] analoges Signal = Analog 0 [Pin A0 (ADS1115 - KY-053)] ADS1115 - KY-053: VDD = 3,3V [Pin 01] GND = Masse [Pin 09] SCL = GPIO03 / SCL [Pin 05] SDA = GPIO02 / SDA [Pin 03] A0 = s.o. [Sensor: analoges Signal] Beispielprogramm Download RPi_AnalogSensor.zip Zu starten mit dem Befehl: sudo python RPi_AnalogSensor.py Ausgabe: 29.04.
PAGE 188
KY-039 Herzschlag Sensor Modul KY-039 Herzschlag Sensor Modul Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ....................................................................................
PAGE 189
KY-039 Herzschlag Sensor Modul Schaltet man vor dem Transistor einen Widerstand in Reihe, so ergibt sich folgendes Verhalten, wenn man die Spannung über den Transistor misst: Scheint auf den Transistor viel Licht bzw. ist es außen hell, so kan man eine niedrige Spannung nahe 0V gemessen - ist der Transistor im Dunklen, so lässt dieser einen relativ kleinen Strom durch und man misst eine Spannung nahe +V.
PAGE 190
KY-039 Herzschlag Sensor Modul Dieses zeigt auf der Y-Achse die Veränderung der Spannung am Fototransistor - somit die Helligkeitsveränderungen hervorgerufen durch das fließende Blut. Die oben gekennzeichneten Spitzen ergeben somit das Schlagen vom Herz. Rechnet man nun die registrierten Schläge pro aufgenommener Zeit, so kommt man auf einen Puls von ca. 71 Schläge/Minute (bpm) Wie man auf dem oberen Oszilloskop-Bild zudem sehen kann, ist das aufgenommene Signal relativ klein bzw.
PAGE 191
KY-039 Herzschlag Sensor Modul 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. Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 192
KY-039 Herzschlag Sensor Modul Pin-Belegung Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 193
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.
PAGE 194
KY-039 Herzschlag Sensor Modul // als der letzte maximale Wert, so wird das als Spitze der aufgezeichnten Daten erkann 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.
PAGE 195
KY-039 Herzschlag Sensor Modul Anschlussbelegung Arduino: Sensor Signal = [Pin 0] Sensor +V = [5V] Sensor - = [Pin GND] Beispielprogramm Download KY-039-HeartBeatDetector original by DanTruong KY-039-HeartBeatDetector deutsche Version by Joy-It Codebeispiel Raspberry Pi !! Achtung !! Analoger Sensor !! Achtung !! Der Raspberry Pi besitzt im Gegensatz zum Arduino keine analogen Eingänge bzw. es ist kein ADC (analog digital Converter) im Chip des Raspberry Pi's integriert.
PAGE 196
KY-039 Herzschlag Sensor Modul #################################################################################################### ### Copyright by Joy-IT ### Published under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License ### Commercial use only after permission is requested and granted ### ### Parts of Code based on Dan Truong's KY039 Arduino Heartrate Monitor V1.0 ### [https://forum.arduino.cc/index.php?topic=209140.
PAGE 197
KY-039 Herzschlag Sensor Modul ######################################################################################## # Hier wird der Ausgangs-Pin deklariert, an dem der Buzzer angeschlossen ist. def heartBeatDetect(schwelle): global maxValue global isPeak global result global oldBeatTime # Hier wird der aktuelle Spannungswert am Fototransistor ausgelesen # und in der rawValue - Variable zwischengespeichert # Mit "adc_channel" wird der am ADC angeschlossene Channel ausgewaehlt rawValue = adc.
PAGE 198
KY-039 Herzschlag Sensor Modul # # # # # # ######## Hauptprogrammschleife ######## Das Programm sieht vor, dass im Abstand der eingestellten "delayTime" (Standard: 10ms) die Funktion zur Herzschlagdetektion aufgerufen wird. Wurde ein Herzschlag erkannt, so wird der Puls ausgegeben. try: while True: time.sleep(delayTime) beatsPerMinute = heartBeatDetect(schwelle) if result == True: print "---Herzschlag erkannt !--- Puls:", int(beatsPerMinute),"(bpm)" except KeyboardInterrupt: GPIO.
PAGE 199
KY-040 Kodierter Drehschalter (Rotary Encoder) KY-040 Kodierter Drehschalter (Rotary Encoder) Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Kodierung .......................................................
PAGE 200
KY-040 Kodierter Drehschalter (Rotary Encoder) Im Uhrzeigersinn [A ändert sich zuerst] -> Pin_CLK A B 0 0 1 0 1 1 0 1 0 0 Gegen den Uhrzeigersinn [B ändert sich zuerst] -> Pin_DT A B 0 0 0 1 1 1 1 0 0 0 Pin-Belegung 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.
PAGE 201
KY-040 Kodierter Drehschalter (Rotary Encoder) 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.
PAGE 202
KY-040 Kodierter Drehschalter (Rotary Encoder) if (Richtung) { Serial.println ("Im Uhrzeigersinn"); } else { Serial.println("Gegen den Uhrzeigersinn"); } Serial.print("Aktuelle Position: "); Serial.println(Counter); Serial.
PAGE 203
KY-040 Kodierter Drehschalter (Rotary Encoder) PIN_DT = 15 BUTTON_PIN = 14 GPIO.setup(PIN_CLK, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(PIN_DT, GPIO.IN, pull_up_down = GPIO.PUD_UP) GPIO.setup(BUTTON_PIN, GPIO.IN, pull_up_down = GPIO.PUD_UP) # Benötigte Variablen werden initialisiert Counter = 0 Richtung = True PIN_CLK_LETZTER = 0 PIN_CLK_AKTUELL = 0 delayTime = 0.01 # Initiales Auslesen des Pin_CLK PIN_CLK_LETZTER = GPIO.
PAGE 204
KY-040 Kodierter Drehschalter (Rotary Encoder) Anschlussbelegung Raspberry Pi: CLK = GPIO16 [Pin 36] DT = GPIO15 [Pin 10] SW = GPIO14 [Pin 8] + = 3,3V [Pin 1] GND = Masse [Pin 6] Beispielprogramm Download KY-040_RPi_RotaryEncoder.zip Zu starten mit dem Befehl: sudo python KY-040_RPi_RotaryEncoder.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 205
KY-050 Ultraschallabstandssensor KY-050 Ultraschallabstandssensor Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ................................................................................
PAGE 206
KY-050 Ultraschallabstandssensor Pin-Belegung Funktionsprinzip Dieses Modul zeigt auf, wie man mittels eines Ultraschalllautsprechers und eines Mikrofons den Abstand berührungslos zu einem Objekt messen kann. Das Prinzip basiert darauf, dass die Schallgeschwindigkeit in der Luft bei gleichbleibender Temperatur nahezu konstant bleibt - bei 20°C beträgt sie 343,2m/s. Aus diesem Fakt kann man die Abstandsmessung in eine Zeitmessung überführen, welche dann von Mikrokontrollern einfach übernommen werden kann.
PAGE 207
KY-050 Ultraschallabstandssensor Im hier vorgestellten Sensormodul sendet der Ultraschalllautsprecher acht 40KHz Signale aus, welche dann von einem Gegenstand reflektiert und vom Mikrofon aufgenommen werden können. Ultraschall wird verwendet, da es sich außerhalb des Hörbereiches des menschlichen Gehörsinns befindet (grob 20Hz-22.000 Hz). Das Aussenden des Ultraschallsignals wird gestartet, in dem am "Trigger Eingangs-Pin" ein 10µs langes Startsignal (ActiveHigh) empfangen wird.
PAGE 208
KY-050 Ultraschallabstandssensor #define Echo_EingangsPin 7 // Echo Eingangs-Pin #define Trigger_AusgangsPin 8 // Trigger Ausgangs-Pin // Benoetigte Variablen werden definiert int maximumRange = 300; int minimumRange = 2; long Abstand; long Dauer; void setup() { pinMode(Trigger_AusgangsPin, OUTPUT); pinMode(Echo_EingangsPin, INPUT); Serial.
PAGE 209
KY-050 Ultraschallabstandssensor Codebeispiel Raspberry Pi !! Achtung !! 5V Spannungslevel !! Achtung !! Der Raspberry Pi arbeitet mit seinem ARM-Prozessorkern, anders als der auf Atmel Atmega basierende Arduino, mit 3,3V Spannungslevel, anstatt mit 5V - dieser Sensor funktioniert jedoch nur mit dem höheren Spannungslevel. Würde man den Sensor uneingeschränkt am Raspberry Pi ohne Vorsichtsmaßnahmen betreiben, könnten dies bei den Eingängen des Raspberry Pi's permanente Schäden hervorrufen.
PAGE 210
KY-050 Ultraschallabstandssensor EinschaltZeit = time.time() # Es wird solange die aktuelle Zeit gespeichert, bis da while GPIO.input(Echo_EingangsPin) == 1: AusschaltZeit = time.
PAGE 211
KY-050 Ultraschallabstandssensor sudo python KY-050-RPi_UltraschallAbstandSensor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 212
KY-051 Voltage Translator / Level Shifter KY-051 Voltage Translator / Level Shifter Bild Technische Daten / Kurzbeschreibung Dieser Level-Shifter wandelt digitale Signale von einer Spannung in eine andere herunter bzw. herauf. Hierzu gibt es 4 verfügbare Kanäle, die umgewandelt werden können. In der heutigen Zeit gibt es eine Vielzahl ein Mikrokontrollersystemen, die in verschiedenen Spannungsbereichen operieren: So arbeiten z.B.
PAGE 213
KY-051 Voltage Translator / Level Shifter Will man jedoch zwischen zwei Systemen mit zwei verschiedenen Spannungslevel kommunizieren (wie das untere Beispiel Arduino -> Raspberry Pi), so muss der Spannungslevel "geshiftet" werden - Wird dieses nicht getan, so muss dasjenige System mit dem niedrigeren Spannungslevel die überschüssige Spannung an den Eingangsstufen "in Wärme verbrauchen". Dieses kann je nach System zu dauerhaften Schäden am System führen.
PAGE 214
KY-051 Voltage Translator / Level Shifter VCCb = [Pin 5V] B1 = [Pin 03] B2 = [Pin 04] B3 = [Pin 05] B4 = [Pin 06] GND = [Pin GND] Anschlussbelegung Raspberry Pi: VCCa = 3,3V [Pin 01] A1 = GPIO18 [Pin 12] A2 = GPIO03 / SCL [Pin 05] A3 = GPIO02 / SDA [Pin 01] A4 = GPIO14 [Pin 08] GND = GND [Pin 09] Bitte achten Sie, dass beide Systeme am selben GND (Masse) verbunden sind - OE muss bei diesem Modul nicht verbunden werden. Ausgabe: 29.04.
PAGE 215
KY-052 Drucksensor / Temperatursensor - BMP180 - KY-052 Drucksensor / Temperatursensor - BMP180 Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..................................................
PAGE 216
KY-052 Drucksensor / Temperatursensor - BMP180 - Pin-Belegung *Dieser Sensor erlaubt es sowohl an 5V System, sowie an 3,3V Systemen angeschlossen und betrieben zu werden.
PAGE 217
KY-052 Drucksensor / Temperatursensor - BMP180 // Falls der Sensor nicht erkannt wurde, wird hier eine Fehlermeldung gezeigt if(!BMPSensor.begin()) { Serial.println("KY-053-Sensor nicht erkannt!"); Serial.print("Bitte ueberpruefen Sie die Verbindung"); while(1); } } void loop(void) { // Initialisierung Adafruit BMP Library sensors_event_t event; BMPSensor.getEvent(&event); // Messung wird gestartet, falls Sensor bereit if (event.pressure) { Serial.
PAGE 218
KY-052 Drucksensor / Temperatursensor - BMP180 3,3 = [N.C.] Software-Beispiel Raspberry Pi Das Programm nutzt zur Ansteuerung des BMP180, der auf diesem Sensor-Modul verbaut ist, die entsprechenden BMP085/180 und I2C Python-Libraries der Firma Adafruit. Diese wurden unter dem folgenden Link unter der MIT OpenSource-Lizenz veröffentlicht. Diese muss vorab erst installiert werden.
PAGE 219
KY-052 Drucksensor / Temperatursensor - BMP180 sudo apt-get install python-smbus i2c-tools -y Hiernach kann das folgende Python-Code Beispiel verwendet werden. Das Programm startet die Messung am Sensor und gibt die gemessenen Werte für den Luftdruck, der Temperatur und der Höhe überm Meeresspiegel aus. #!/usr/bin/python # coding=utf-8 # Copyright (c) 2014 Adafruit Industries # Benoetigte Bibliotheken werden eingefügt und konfiguriert import Adafruit_BMP.
PAGE 220
KY-052 Drucksensor / Temperatursensor - BMP180 Beispielprogramm Download KY-052-RPi_DruckSensor_TemperaturSensor.zip Zu starten mit dem Befehl: sudo python KY-052-RPi_DruckSensor_TemperaturSensor.py Ausgabe: 29.04.2016 Copyright by Joy-IT - Published under CC BY-NC-SA 3.
PAGE 221
KY-053 Analog Digital Converter KY-053 Analog Digital Converter Inhaltsverzeichnis 1 Bild ....................................................................................................................................................................... 1 2 Technische Daten / Kurzbeschreibung ................................................................................................................. 1 3 Pin-Belegung ..................................................................................
PAGE 222
KY-053 Analog Digital Converter Pin-Belegung Die Pin-Belegung ist auf der Modulplatine aufgedruckt Codebeispiel Arduino Die Arduino-Boards besitzen von Haus aus einen 10 Bit-ADC mit 6 Kanälen. Benötigt man jedoch mehr Kanäle oder eine höhere Genauigkeit, dann kann man den Arduino mittels des KY-053 Analog Digital Converter Moduls um 4 ADC Kanäle mit 12-Bit Genauigkeit erweitern, welches per I2C an den Arduino angeschlossen wird.
PAGE 223
KY-053 Analog Digital Converter #include #include // ADS1115 Modul wird initialisiert - alle folgenden Operationen mit dem ADC // können mit Hilfe des Objektes "ads" ausgeführt werden. Adafruit_ADS1115 ads; void setup(void) { Serial.begin(9600); Serial.println("Werte der analogen Eingaenge des ADS1115 (A0..A3) werden ausgelesen und ausge Serial.println("ADC Range: +/- 6.144V (1 bit = 0.
PAGE 224
KY-053 Analog Digital Converter Serial.print("Analog Eingang 3: "); Serial.print(voltage3);Serial.println("mV"); Serial.println("------------------------"); delay(1000); } Beispielprogramm Download: KY-053-AnalogDigitalConverter.zip Anschlussbelegung Arduino: VDD = [Pin 5V] GND = [Pin GND] SCL = [Pin SCL] SDA = [Pin SDA] ADDR = [N.C.] ALRT = [N.C.
PAGE 225
KY-053 Analog Digital Converter Die Datei kann mit folgenden Befehl editiert werden: sudo nano /boot/config.txt Mit der Tastenfolge [Strg+X -> Y -> Enter] kann die Datei, nach dem hinzufügen der Zeile am unteren Ende, gespeichert und geschlossen werden. Außerdem werden zusätzliche Bibliotheken benötigt, um I2C innerhalb Python nutzen zu können.
PAGE 226
KY-053 Analog Digital Converter sps = # sps # sps # sps # sps 64 # = 128 = 250 = 475 = 860 64 Samples pro Sekunde # 128 Samples pro Sekunde # 250 Samples pro Sekunde # 475 Samples pro Sekunde # 860 Samples pro Sekunde # ADC-Channel adc_channel_0 adc_channel_1 adc_channel_2 adc_channel_3 (1-4) wird ausgewaehlt = 0 # Channel 0 = 1 # Channel 1 = 2 # Channel 2 = 3 # Channel 3 # Hier wird der ADC initialisiert - beim KY-053 verwendeten # ADC handelt es sich um einen ADS1115 Chipsatz adc = ADS1x15(ic=ADS1115
PAGE 227
KY-053 Analog Digital Converter A3 = Messspitze Analog 3 [Zu messende Spannung | z.B. Sensorausgang] Beispielprogramm Download KY-053_RPi_AnalogDigitalConverter.zip Zu starten mit dem Befehl: sudo python KY-053_RPi_AnalogDigitalConverter.py Erweiterte Funktionen des ADS1115 ADC Die Funktion des ADS1115, die in den oben aufgezeigten Codebeispielen zur Verwendung kommt, nennt sich "Single Ended Conversion" und besagt, dass eine Messung am einzelnen ausgewählten Kanal gegen Masse erfolgt.