KY-050..KY-055

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

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                        Wels, am 2017-01-12

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

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************

715_d_ARDUINO-x_jOY-iT Arduino 37-in-1 Sensor Kit X40 +++ Beschreibung (227 Seiten)_1a.pdf



KY-050 Ultraschallabstandssensor HC-SR04







ACHTUNG: Immer genau nach Sketch den HC-SR04 verbinden ! ! !

Anschlussbelegung Arduino:
Vcc                = [pin+5V]
Echo             = [pin-7]
Trigger           = [pin-8]
Sensor GND  = [pin-GND]



Anschlussbelegung Arduino:


Vcc                      =  +5Vdc
Echo                   = pin-7
Trigger               =  pin-8
Sensor GND    =  GND


Kurzbeschreibung
Wird am Trigger-Eingang ein Signal (fallende Flanke) eingegeben, so wird eine Abstandsmessung durchgeführt und am Echo-Ausgang als PWM-TTL Signal ausgegeben
Messbare Distanz: 2 .. 300cm
Messauflösung: 3mm
min. Zeit zwischen den Messungen: 50μs

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.




#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.begin (9600);
}
void loop() {
// Abstandsmessung wird mittels des 10us langen Triggersignals gestartet
digitalWrite(Trigger_AusgangsPin, HIGH);
delayMicroseconds(10);
digitalWrite(Trigger_AusgangsPin, LOW);
// Nun wird am Echo-Eingang gewartet, bis das Signal aktiviert wurde
// und danach die Zeit gemessen, wie lang es aktiviert bleibt
Dauer = pulseIn(Echo_EingangsPin, HIGH);
// Nun wird der Abstand mittels der aufgenommenen Zeit berechnet
Abstand = Dauer/58.2;
// Überprüfung ob gemessener Wert innerhalb der zulässingen Entfernung liegt
if (Abstand >= maximumRange || Abstand <= minimumRange)
{
// Falls nicht wird eine Fehlermeldung ausgegeben.
Serial.println("Abstand außerhalb des Messbereichs");
Serial.println("-----------------------------------");
}
else
{
// Der berechnete Abstand wird in der seriellen Ausgabe ausgegeben
Serial.print("Der Abstand betraegt:");
Serial.print(Abstand);
Serial.println("cm");
Serial.println("-----------------------------------");
}
// Pause zwischen den einzelnen Messungen
delay(500);
}



Seite 207
715_d_ARDUINO-x_jOY-iT Arduino 37-in-1 Sensor Kit X40 +++ Beschreibung (227 Seiten)_1a.pdf

http://www.instructables.com/id/Ultrasonic-distance-meter-with-LCD-display-on-Ardu/



KY-050 Ultraschallabstandssensor

Wird am Trigger-Eingang ein Signal (fallende Flanke) eingegeben, so wird eine Abstandsmessung durchgeführt und am Echo-Ausgang als PWM-TTL Signal ausgegeben
messbare Distanz: 2cm .. 300cm
Messauflösung: 3mm
min. Zeit zwischen den Messungen:  50µs

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.

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.000Hz).
Das Aussenden des Ultraschallsignals wird gestartet, in dem am "Trigger Eingangs-Pin" ein 10µs langes Startsignal (ActiveHigh) empfangen wird.
Nach dem Aussenden wird am "Echo Ausgang-Signal Pin" das Signal aktiviert (ActiveHigh).
Wird nun am Mikrofon das reflektierte Signal wieder aufgenommen, so wird nach der Detektion das Echo-Signal wieder deaktiviert.
Die Zeit zwischen der Aktivierung und der Deaktivierung des Echosignals kann gemessen und in den Abstand umgerechnet werden,
da dies auch der Zeit entspricht, wie lang das Ultraschallsignal gebraucht hat um in der Luft die Strecke zwischen Lautsprecher->reflektierende Wand -> Mikrofon zu überwinden.
Die Umrechnung erfolgt dann über die Annäherung einer konstanten Luftgeschwindigkeit - der Abstand ist dann folglich die Hälfte der zurückgelegten Strecke.




Codebeispiel Arduino

Das Beispielprogramm aktiviert nach o.g. Prinzip die Abstandsmessung und misst mit Hilfe der Arduino Funktion pulseIn die Zeit, wie lang das Ultraschallsignal in der Luft ist.
Diese Zeit wird dann für die Umrechnung des Abstands als Basis genommen - das Ergebnis wird danach in der seriellen Ausgabe ausgegeben.
Sollte das Signal außerhalb des Messbereichs sein, wird eine entsprechende Fehlermeldung ausgegeben.

#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.begin (9600);
}
 
void loop() {
 
 // Abstandsmessung wird mittels des 10us langen Triggersignals gestartet
 digitalWrite(Trigger_AusgangsPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(Trigger_AusgangsPin, LOW);
  
 // Nun wird am Echo-Eingang gewartet, bis das Signal aktiviert wurde
 // und danach die Zeit gemessen, wie lang es aktiviert bleibt
 Dauer = pulseIn(Echo_EingangsPin, HIGH);
  
 // Nun wird der Abstand mittels der aufgenommenen Zeit berechnet
 Abstand = Dauer/58.2;
  
 // Überprüfung ob gemessener Wert innerhalb der zulässingen Entfernung liegt
 if (Abstand >= maximumRange || Abstand <= minimumRange)
 {
    // Falls nicht wird eine Fehlermeldung ausgegeben.
      Serial.println("Abstand außerhalb des Messbereichs");
      Serial.println("-----------------------------------");
 
  
 else
 {
    // Der berechnete Abstand wird in der seriellen Ausgabe ausgegeben
      Serial.print("Der Abstand betraegt:");
      Serial.print(Abstand);
      Serial.println("cm");
      Serial.println("-----------------------------------");
 }
  // Pause zwischen den einzelnen Messungen
 delay(500);
}



KY-050-UltraschallabstandSensor.zip

http://sensorkit.joy-it.net/index.php?title=KY-050_Ultraschallabstandssensor



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






HC-SR04 Project

Früher haben wir ein Projekt mit einem Infrarot-Abstandsmessprojekt mit dem GP2D12-Modul von Sharp durchgeführt.
Dies ist eine gute Lösung für Innenprojekte und kann Objekte bis zu 80 cm erkennen.
Zur Erfassung von Objekten können wir ein Ultraschallreichweitenmodul verwenden.
Auch der HC-SR04 ist günstiger als der GP2D12. In diesem Projekt werden wir das Ultraschallmodul HC-SR04 mit einem Arduino verwenden.

Der HC-SR04 verwendet Ton statt Licht wie das GP2D12-Modul. Der HC-SR04 sendet ein Ping als Unterseeboot und misst die Zeit zwischen Senden und Empfangen von etwas zurück, wenn sich ein Objekt vor dem Sensor befindet.
Durch die Verwendung von Ton für seine Messungen können wir bis zu 4 Meter erreichen.
Das Modul ist ca. 45x20x15 mm groß und hat einen 4-poligen Anschluss.
Zur Spannungsversorgung des Moduls mit 5 Volt werden zwei Pins benötigt.
Der Arbeitsstrom beträgt ca. 15 mA. Ein Pin ist der Trigger-Ping und der letzte wird verwendet, um das Ergebnis der Messungen, die Echo-Pin zu lesen.
Der Messwinkel des HC-SR04 beträgt 15 Grad. Bei 4 Meter Abstand sollte dies ein Strahl von etwa 1 Meter sein.
Bei 1 Meter das ist 26 cm, so müssen wir dies im Auge behalten, wenn Sie diese Informationen.
Ein Ping des HC0SR04 besteht tatsächlich aus 8 Pulsen bei 40 kHz, um die Messung durchzuführen.
Um einen Ping zu starten, müssen Sie einen Impuls von 10us am Triggereingang bereitstellen.
Wenn der Abstand durch die 8 Impulse gemessen wird, setzt der HC0SR04 einen Impuls auf den Echo-Pin. Sie können den Abstand mit der Länge des Echoimpulses und der Schallgeschwindigkeit berechnen.
Die Schallgeschwindigkeit beträgt 340 m / s oder 2,9 Mikrosekunden pro mm.
Wir müssen die Länge des Pulses durch 2,9 dividieren, um das Ergebnis in mm zu erhalten.
Der Ping fährt zu einem Objekt und wieder zum Sensor zurück.
Aus diesem Grund müssen wir das Ergebnis durch zwei dividieren. Zwischen zwei Pings müssen wir einen 60ms Messzyklus behalten.


Der Anschluss des HC-SR04 an ein Arduino ist wirklich geradeaus.
Schließen Sie einfach die 5 Volt und die Masse zu den äußeren Stiften an. In diesem Beispiel ist der Trigger-Pin mit 8 verbunden und der Echo-Pin mit dem 9 des Arduino.
Das Bild oben wurde mit Fritzing bei Fritzing.org erstellt. Dort finden Sie auch die Schaltpläne.



Im wirklichen Leben ist dies das Setup, das ich in meinem Fall verwendet habe.
Hüten Sie sich vor dem kleinen Unterschied zwischen dem Foto und dem Schema oben.
Ich drehte die HC-Sr04 180 Grad, damit es es an den Rand der Platine.



Arduino Code

/*
HC-SR04 for Arduino

Original project from http://www.swanrobotics.com

This project demonstrates the HC-SR
The distance presented in the code is in mm, but you can uncomment the line for distance in inches.
The schematics for this project can be found on http://www.swanrobotics.com

This example code is in the public domain.
*/

const int TriggerPin = 8; //Trig pin
const int EchoPin = 9; //Echo pin
long Duration = 0;

void setup(){
pinMode(TriggerPin,OUTPUT); // Trigger is an output pin
pinMode(EchoPin,INPUT); // Echo is an input pin
Serial.begin(9600); // Serial Output
}

void loop(){
digitalWrite(TriggerPin, LOW);
delayMicroseconds(2);
digitalWrite(TriggerPin, HIGH); // Trigger pin to HIGH
delayMicroseconds(10); // 10us high
digitalWrite(TriggerPin, LOW); // Trigger pin to HIGH

Duration = pulseIn(EchoPin,HIGH); // Waits for the echo pin to get high
// returns the Duration in microseconds
long Distance_mm = Distance(Duration); // Use function to calculate the distance

Serial.print("Distance = "); // Output to serial
Serial.print(Distance_mm);
Serial.println(" mm");

delay(1000); // Wait to do next measurement
}

long Distance(long time)
{
// Calculates the Distance in mm
// ((time)*(Speed of sound))/ toward and backward of object) * 10

long DistanceCalc; // Calculation variable
DistanceCalc = ((time /2.9) / 2); // Actual calculation in mm
//DistanceCalc = time / 74 / 2; // Actual calculation in inches
return DistanceCalc; // return calculated value
}

Screen shot of the serial monitor in the Arduino IDE.

HC-SR04-5

 

Sources:
http://www.elecfreaks.com/244.html
http://arduino.cc/en/Tutorial/Ping
http://www.fritzing.org


Quelle:
http://www.swanrobotics.com/projects/hc-sr04_project/





*********************************************************
KY-051 Voltage Translator / Level Shifter
Have one to sell? Sell now

TXB0104 Bidirectional Voltage Level Translator shifter arduino 5V to 3V I2C SPI




3,3V zu 5,0V translation
5,0V zu 3,3V translation

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. die Ein- und Ausgänge von älteren Systemen wie Arduino, basierend auf einen Atmega-Controller, mit 5V-Level, die neueren Raspberry-Pi Computer die auf einen ARMController basieren, mit einem Spannungslevel von 3,3V.

VCCb   = [pin+5V]
B1       = [pin-03]
B2       = [pin-04]
B3       = [pin-05]
B4       = [pin-06]
GND    = [pin-GND]


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. die Ein- und Ausgänge von älteren Systemen wie Arduino, basierend auf einen Atmega-Controller, mit 5V Level, die neueren Raspberry-Pi Computer die auf einen ARM-Controller basieren, mit einem Spannungslevel von 3,3V.
Dies ist damit zu begründen, dass bei der Kommunikation zwischen Mikrokontrollern früher mit höheren Spannungen gearbeitet werden musste, da die Eingangsstufen aufgrund von Rauschen/Störungen in den Leitungen einen höheren Abstand zwischen dem Spannungslevel für [Digital EIN] = 5V und für [Digital AUS] = 0V benötigt haben -
Im Zuge der Modernisierung sind Ein-/Ausgangsstufen der Kontroller bedeutend besser geworden und man möchte heutzutage die eingesetzte Spannung so gering wie möglich halten, damit Wärmeentwicklung und Stromverbauch sinken.
So ist heutzutage auch der Einsatz von 1,8V Systemen nicht unüblich.
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.




Die Pin-Belegung ist auf der Modulplatine aufgedruckt.
Die Signale an den Ein-/Ausgängen A1-A4, sowie B1-B4 werden auf das jeweilige Spannungslevel geshiftet
(VCCa -> A1-A4 | VCCb -> B1-B4)



Anschlussbelegung ARDUINO UNO R3
VCCb =  5V
B1 = pin-3
B2 = pin-4
B3 = pin-5
B4 = pin-6
GND =  GND


http://www.linkerkit.de/index.php?title=KY-051_Voltage_Translator_/_Level_Shifter
http://sensorkit.joy-it.net/index.php?title=KY-051_Voltage_Translator_/_Level_Shifter


https://www.sparkfun.com/products/12009

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


SparkFun Voltage-Level Translator Breakout - TXB0104


https://learn.sparkfun.com/tutorials/txb0104-level-shifter-hookup-guide


Beschreibung:
Dies ist ein Breakout Board für das Texas Instruments TXB0104 Modul.
Der TXB0104 ist ein 4-Bit bidirektionaler Spannungspegel-Umsetzer mit automatischer Richtungserkennung.

Dieser 4-Bit-Noninverting-Translator verwendet zwei getrennte konfigurierbare Stromversorgungsschienen. Der A-Port dient zur Überwachung von VCCA. VCCA akzeptiert jegliche Versorgungsspannung von 1,2 V bis 3,6 V. Der B-Port ist dafür ausgelegt, VCCB zu verfolgen. VCCB akzeptiert jegliche Versorgungsspannung von 1,65 V bis 5,5 V. Dies ermöglicht eine universelle bidirektionale Niederspannungsübersetzung zwischen jedem der 1,2 V-, 1,5 V-, 1,8 V-, 2,5 V-, 3,3 V- und 5 V-Spannungsknoten. VCCA sollte VCCB nicht überschreiten. Wir haben jeden Pin auf diesem Modul ausgebrochen, damit Sie sowohl den A- als auch den B-Anschluss bequem erreichen können.

Eigenschaften:

     1,2 V bis 3,6 V an A-Anschluss und 1,65 V bis 5,5 V an B-Anschluss (VCCA ≤ VCCB)
     VCC-Isolationsfunktion - Wenn entweder VCC-Eingang GND ist, befinden sich alle Ausgänge im Hochimpedanzzustand
     OE-Eingangsschaltung auf VCC bezogen
     Niedriger Energieverbrauch, 5-μA Max ICC


https://www.sparkfun.com/products/11771


Datenblatt TXB0104
http://cdn.sparkfun.com/datasheets/BreakoutBoards/txb0104.pdf




*********************************************************
KY-052 Drucksensor / Temperatursensor [BMP180]

http://sensorkit.joy-it.net/index.php?title=KY-052_Drucksensor_/_Temperatursensor_-_BMP180_-
http://sensorkit.joy-it.net/index.php?title=KY-052_Drucksensor_/_Temperatursensor_-_BMP180_-


KY-052 Drucksensor / Temperatursensor [BMP180]
Dieser Drucksensor misst den Luftdruck am Sensorausgang (kleines Loch am silbernen Sensorgehäuse) und gibt das Ergebnis kodiert auf den I2C-Bus aus.
Für diesen Sensor wird eine entsprechende Software benötig


KY-052-DruckSensor_TemperaturSensor.zip

Anschlussbelegung Arduino:
VCC = [Pin 5V]
GND = [Pin GND]
SCL = [Pin SCL]
SDA = [Pin SDA]

Anschlussbelegung Arduino:

VCC = [Pin 5V]
GND = [Pin GND]
SCL = [Pin SCL]
SDA = [Pin SDA]
3,3 = [N.C.]


Dieser Drucksensor misst den Luftdruck am Sensorausgang (kleines Loch am silbernen Sensorgehäuse) und gibt das Ergebnis kodiert auf den I2C-Bus aus.
Für diesen Sensor wird eine entsprechende Software benötigt

// Benoetigte Libraries werden eingefügt und konfiguriert
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085_U.h>
Adafruit_BMP085_Unified BMPSensor = Adafruit_BMP085_Unified(10085);
void setup(void)
{
Serial.begin(9600);
Serial.println("KY-052 SensorTest:");
// 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.println("------------------------");
// Messung des Luftdrucks
Serial.print("Luftdruck: ");
Serial.print(event.pressure);
Serial.println(" hPa");
// Messung der aktuellen Temperatur
float temperature;
BMPSensor.getTemperature(&temperature);
Serial.print("Temperatur: ");
Serial.print(temperature);
Serial.write(176); // UniCode-Angabe eines char-Symbols für das "°-Symbol"
Serial.println(" C");
// Berechnung der Hoehe ueber dem Meeresspiegel,
// aus den aufgenommenen Daten (SLP=1013.25 hPa)
float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA;
Serial.print("Meereshoehe: ");
Serial.print(BMPSensor.pressureToAltitude(seaLevelPressure,
event.pressure,
temperature));
Serial.println(" m");
Serial.println("------------------------");
Serial.println("");
}
// Fehlermeldung falls Sensor nicht ausgelesen werden kann
else
{
Serial.println("Sensor-Fehler");
}
delay(1000);
}


https://www.adafruit.com/product/1603

KY-052 Drucksensor / Temperatursensor - BMP180

  • *Dieser Sensor erlaubt es sowohl an 5V System, sowie an 3,3V Systemen angeschlossen und betrieben zu werden. 
  • Hierbei ist zu beachten, dass nur einer der jeweiligen Spannungsversorgungspins angeschlossen wird; passend zum Spannungslevel des verwendeten Systems
  • - weiteres entnehmen Sie den unteren Beispielen zum Anschluss des Arduino (5V) oder des Rasperry Pi's (3,3V)

Software-Beispiel Arduino

Dieser Sensor gibt sein Messergebnis nicht als Signal auf einen Ausgangspin aus, sondern kommuniziert diesen per I2C-Bus.
Über diesen lässt sich der Sensor ansteuern und die jeweiligen Messungen zum Druck und der Temperatur starten und auswerten.
Zur Ansteuerung dieses Sensormoduls gibt es mehrere Möglichkeiten - als besonders zugänglich hat sich die Adafruit_BMP085 Library erwiesen, die die Firma Adafruit unter dem folgenden Link unter der OpenSource BSD-Lizenz BSD-Lizenz veröffentlicht hat.
Das unten stehende Beispiel verwendet diese besagte Library - hierzu empfehlen wir diese von Github herunterzuladen, zu entpacken und im Arduino-Library-Ordner, welcher sich standardmäßig unter
(C:\Benutzer\[Benutzername]\Dokumente\Arduino\libraries) befindet, zu kopieren, damit diese für dieses Codebeispiel und folgende Projekte zur Verfügung steht.


Alternativ ist diese auch im unten stehenden Download Paket ebenfalls enthalten.

// Benoetigte Libraries werden eingefügt und konfiguriert
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BMP085_U.h>
Adafruit_BMP085_Unified BMPSensor = Adafruit_BMP085_Unified(10085);
  
void setup(void)
{
  Serial.begin(9600);
   
  Serial.println("KY-052 SensorTest:");
   
  // 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.println("------------------------");
     
    // Messung des Luftdrucks
    Serial.print("Luftdruck:    ");
    Serial.print(event.pressure);
    Serial.println(" hPa");
     
    // Messung der aktuellen Temperatur
    float temperature;
    BMPSensor.getTemperature(&temperature);
    Serial.print("Temperatur: ");
    Serial.print(temperature);
    Serial.write(176); // UniCode-Angabe eines char-Symbols für das "°-Symbol"
    Serial.println(" C");
  
    // Berechnung der Hoehe ueber dem Meeresspiegel,
    // aus den aufgenommenen Daten (SLP=1013.25 hPa)
    float seaLevelPressure = SENSORS_PRESSURE_SEALEVELHPA;
    Serial.print("Meereshoehe:    ");
    Serial.print(BMPSensor.pressureToAltitude(seaLevelPressure,
                                        event.pressure,
                                        temperature));
    Serial.println(" m");
    Serial.println("------------------------");
    Serial.println("");
  }
  // Fehlermeldung falls Sensor nicht ausgelesen werden kann
  else
  {
    Serial.println("Sensor-Fehler");
  }
  delay(1000);
}


KY-052-DruckSensor_TemperaturSensor.zip

http://sensorkit.joy-it.net/index.php?title=KY-052_Drucksensor_/_Temperatursensor_-_BMP180_-




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-053 Analog Digital Converter ADS1115
16-bit I2C ADC+POA


KY-053 Analog Digital Converter
Per entsprechenden Befehlen auf den I2C-Bus, können auf bis zu 4 Eingängen analoge Spannungswerte mit bis zu 16-Bit Genauigkeit gemessen werden.
Das Messergebnis wird kodiert auf den I2C-Bus ausgegeben.
Für dieses Modul wird eine entsprechende Software benötigt



Anschlussbelegung Arduino:
pin-Vdd      = [Pin 5V]

pin-GND     = [Pin GND]
pin-pin-SCL = [Pin SCL]
pin-SDA     = [Pin SDA]
pin-ADDR   = [N.C.]
pin-ALRT    = [N.C.]
pin-A0        = [Messspitze Analog 0]
pin-A1        = [Messspitze Analog 1]
pin-A2        = [Messspitze Analog 2]
pin-A3        = [Messspitze Analog 3]

http://www.bristolwatch.com/arduino2/ard0.htm




Per entsprechenden Befehlen auf den I2C-Bus, können auf bis zu 4 Eingängen analoge Spannungswerte mit bis zu 16-Bit Genauigkeit gemessen werden.
Das Messergebnis wird kodiert auf den I2C-Bus ausgegeben.
Für dieses Modul wird eine entsprechende Software benötigt - siehe Codebeispiele unten.

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.
Zur Ansteuerung dieses Moduls gibt es mehrere Möglichkeiten
- als besonders zugänglich haben sich die ADS1X15 Libraries erwiesen, die die Firma Adafruit
unter [https://github.com/adafruit/Adafruit_ADS1X15] unter der [BSD-Lizenz] veröffentlicht hat.
Das unten stehende Beispiel verwendet diese besagte Library
- hierzu empfehlen wir diese von Github herunterzuladen, zu entpacken und im Arduino-Library-Ordner, welcher sich standardmäßig unter
C:\Benutzer\[Benutzername]\Dokumente\Arduino\libraries
befindet, zu kopieren, damit diese für dieses Codebeispiel und folgende Projekte zur Verfügung steht. Alternativ ist diese auch im unten stehenden Download Paket ebenfalls enthalten.



#include <Wire.h>
#include <Adafruit_ADS1015.h>
// 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 ausgegeben");
Serial.println("ADC Range: +/- 6.144V (1 bit = 0.1875mV)");
// Dieses Modul besitzt an seinen analogen Eingängen Signalverstärker, deren
// Verstärkung per Software in den unten stehenden Bereichen konfiguriert werden
// können.
// Dieses ist in dem Fall gewünscht, wenn ein bestimmter Spannungsbereich
// als messergebnis erwartet wird und man so eine höhere Auflösung des Signals
// erhält.
// Als Standardverstärkung ist Gain=[2/3] gewählt und kann durch Auskommentieren
// auf eine andere Verstärkung umgestellt werden.
// ADS1115
// -------
ads.setGain(GAIN_TWOTHIRDS); // 2/3x gain +/- 6.144V 1 bit = 0.1875mV
// ads.setGain(GAIN_ONE); // 1x gain +/- 4.096V 1 bit = 0.125mV
// ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV
// ads.setGain(GAIN_FOUR); // 4x gain +/- 1.024V 1 bit = 0.03125mV
// ads.setGain(GAIN_EIGHT); // 8x gain +/- 0.512V 1 bit = 0.015625mV
// ads.setGain(GAIN_SIXTEEN); // 16x gain +/- 0.256V 1 bit = 0.0078125mV
ads.begin();
}
void loop(void)
{
uint16_t adc0, adc1, adc2, adc3;
float voltage0, voltage1, voltage2, voltage3;
float gain_conversion_factor;
// Der Befehl "ads.readADC_SingleEnded(0)" ist die eigentliche Operation, die die Messung im ADC startet.
// die "0" als Variable für diese Funktion definiert den verwendeten Channel, der gemessen werden soll
// Soll z.B. der dritte Channel gemessen werden, so muss diese mit der "3" ausgetauscht werden
adc0 = ads.readADC_SingleEnded(0);
adc1 = ads.readADC_SingleEnded(1);
adc2 = ads.readADC_SingleEnded(2);
adc3 = ads.readADC_SingleEnded(3);
// Dieser Wert wird für die Umrechnung in eine Spannung benötigt - dieser ´
// hängt von der eingestellten Verstärkung ab. Der passende Wert zur Verstärkung
// sollte aus der oben aufgezeigten Tabelle entnommen werden
gain_conversion_factor= 0.1875;
// Umrechnung der aufgezeichneten Werte in eine Spannung
voltage0 = (adc0 * gain_conversion_factor);
voltage1 = (adc1 * gain_conversion_factor);
voltage2 = (adc2 * gain_conversion_factor);
voltage3 = (adc3 * gain_conversion_factor);
// Ausgabe der Werte auf die serielle Schnittstelle
Serial.print("Analog Eingang 0: "); Serial.print(voltage0);Serial.println("mV");
Serial.print("Analog Eingang 1: "); Serial.print(voltage1);Serial.println("mV");
Serial.print("Analog Eingang 2: "); Serial.print(voltage2);Serial.println("mV");
Serial.print("Analog Eingang 3: "); Serial.print(voltage3);Serial.println("mV");
Serial.println("------------------------");
delay(1000);
}



http://sensorkit.joy-it.net/index.php?title=KY-053_Analog_Digital_Converter
https://www.adafruit.com/product/1085






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


Arduino ADS1115 16 Bit DAC Module Pin Outs


http://henrysbench.capnfatz.com/henrys-bench/arduino-voltage-measurements/arduino-ads1115-module-getting-started-tutorial/




ADS1115 16-Bit ADC - 4 Channel with Programmable Gain Amplifier

300_d_Adafruit-x_4-Kanal ADC Breakouts - Anleitung (19 Seiten)_1a.pdf

https://learn.adafruit.com/adafruit-4-channel-adc-breakouts/programming
https://www.adafruit.com/product/1085



Programming ADS1115 4-Channel I2C ADC with Arduino


Read pot on AIN1 convert value to voltage
then display on Arduino serial monitor.

By Lewis Loflin lewis@bvu.net
http://www.sullivan-county.com/main.htm
Electronics website:
http://www.bristolwatch.com/index.htm 

*/

#include <Wire.h> // specify use of Wire.h library
#define ASD1115 0x48

unsigned int val = 0;
byte writeBuf[3];
byte buffer[3];

const float VPS = 4.096 / 32768.0; // volts per step

void setup()   {

  Serial.begin(9600); 
  Wire.begin(); // begin I2C

  // ASD1115
  // set config register and start conversion
  // ANC1 and GND, 4.096v, 128s/s
  writeBuf[0] = 1;    // config register is 1
  writeBuf[1] = 0b11010010; // 0xC2 single shot off
  // bit 15 flag bit for single shot
  // Bits 14-12 input selection:
  // 100 ANC0; 101 ANC1; 110 ANC2; 111 ANC3
  // Bits 11-9 Amp gain. Default to 010 here 001 P19
  // Bit 8 Operational mode of the ADS1115.
  // 0 : Continuous conversion mode
  // 1 : Power-down single-shot mode (default)

  writeBuf[2] = 0b10000101; // bits 7-0  0x85
  // Bits 7-5 data rate default to 100 for 128SPS
  // Bits 4-0  comparator functions see spec sheet.

  // setup ADS1115
  Wire.beginTransmission(ASD1115);  // ADC 
  Wire.write(writeBuf[0]); 
  Wire.write(writeBuf[1]);
  Wire.write(writeBuf[2]);  
  Wire.endTransmission();  

  delay(500);

}  // end setup

void loop() {

  buffer[0] = 0; // pointer
  Wire.beginTransmission(ASD1115);  // DAC
  Wire.write(buffer[0]);  // pointer
  Wire.endTransmission();

  Wire.requestFrom(ASD1115, 2);
  buffer[1] = Wire.read();  // 
  buffer[2] = Wire.read();  // 
  Wire.endTransmission();  

  // convert display results
  val = buffer[1] << 8 | buffer[2]; 

  if (val > 32768) val = 0;

  Serial.println(val * VPS);
  Serial.println(val);
  
  // just an indicator
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);

} // end loop

Datenblatt
http://www.bristolwatch.com/rpi/geany/ads1115.pdf

http://www.bristolwatch.com/arduino2/ard0.htm







Arduino-16-Bit-Low-Frequency-Datalogger  elektor 130485-11 / 140035-11


Arduino-16-Bit-Low-Frequency-Datalogger

https://www.elektormagazine.com/labs/arduino-16-bit-low-frequency-datalogger-130485-i-140035-i


Arduino ADS1115 Differential Voltmeter Tutorial



Eine 16-Bit-Differenzmessung



ADS1115 ADC Wenn Sie genügend Arduino-Projekte erstellen, müssen Sie eventuell eine Differenzspannungsmessung durchführen. Das heißt, Sie müssen eine Messung durchführen, bei der keine der beiden Seiten der Messung auf dem Arduino-Erdpotential liegt.

Die Stärke des ADS1115-Analog-Digital-Wandlers (ADC) ist nicht nur in der Lage, diese Messung durchzuführen, sondern mit 16 Bit Auflösung.

Ein weiterer Vorteil ist, dass Sie in diesem differenziellen Modus eine negative Spannungsmessung durchführen können.

Dieses kurze Tutorial zeigt, wie diese Messung durchgeführt wird.

    
Wenn Sie neu im ADS1115 sind, möchten Sie vielleicht meinen ersten Artikel auf dem Gerät lesen. Es diskutiert die 16-Bit-Auflösung, Skalierungsfaktor und andere wichtige Geräte-Aspekte.

Am Anfang

Wie in Pin-Out-Zeichnungen unten dargestellt, kommt das Modul ADS1115 in ein paar gemeinsamen Sorten. Sie sind bei jeder der folgenden Verkaufsstellen erhältlich.

Es ist Ihnen nicht erlaubt, Anhänge hochzuladen

ADS1115 Arduino Differential Measurement Tutorial


Sie wollen zu finden, eine Batterie von irgendeiner Art für dieses Tutorial, das eine Zellenspannung von weniger als fünf Volt hat.
Laden und installieren Sie die Adafruit ADS1X15-Bibliothek

Sie benötigen die Adafruit ADS1X15-Bibliothek. Es ist HIER verfügbar.

Wenn Sie nicht mit der Verwendung von Bibliotheken vertraut sind, können Sie diesen Artikel auf der Arduino-Website finden Sie HIER lesen.
Schließen Sie das ADS1115 an Ihr Arduino und eine Batterie an

Die Einrichtung ist einfach. Das heißt, Übung einige Sorge, wenn Sie mit einem Steckbrett. Ich einmal kurzgeschlossen Batterie-Terminals zusammen mit einem (ich war müde). Das Ergebnis war nicht schön.

Arduino ADS1115 Differenzspannungsmesser

Kopieren Einfügen und Hochladen der Arduino ADS1115-Beispiel-Sketch

#include <Wire.h>
#include <Adafruit_ADS1015.h>

Adafruit_ADS1115 ads;  // Declare an instance of the ADS1115

int16_t rawADCvalue;  // The is where we store the value we receive from the ADS1115
float scalefactor = 0.1875F; // This is the scale factor for the default +/- 6.144 Volt Range we will use
float volts = 0.0; // The result of applying the scale factor to the raw value

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

void loop(void)
{  

  rawADCvalue = ads.readADC_Differential_0_1(); 
  volts = (rawADCvalue * scalefactor)/1000.0;
  
  Serial.print("Raw ADC Value = "); 
  Serial.print(rawADCvalue); 
  Serial.print("\tVoltage Measured = ");
  Serial.println(volts,6);
  Serial.println();
  

  delay(1000);
}

Überprüfen Sie Ihre Tutorial-Ausgabe







*********************************************************
                   Ersatz für LDR05
https://learn.adafruit.com/photocells




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

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






Comments