Ultraschall

http://sites.prenninger.com/arduino-uno-r3/arduino---sensoren/ultraschall

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                               Wels, am 2016-11-18

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

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken
********************************************************I*
015_b_PrennIng-a_arduino.uno.r3-arduino...sensoren-ultraschall (xx Seiten)_1a.pdf


     Ultrasonic-Kit für Arduino  € 35,96  $ 30,99

Fa. Sun Founder

The kit has 15 projects for the beginners who are interested in Arduino.



http://www.sunfounder.com/index.php?c=show&model=Ultrasonic Kit&id=21



Das Set verfügt über 15 Projekte für die Anfänger, die in Arduino interessiert sind.

Ein kompletter Satz von Arduino die häufigsten und nützliche elektronische Komponenten.
Ausführliche Anleitungen (44 Seiten Projektbroschüre und Micro DVD) einschließlich der Projekteinführung und deren Quellcode wird mit dem Kit mitgeliefert.

Eigenschaften:
Das Set verfügt über 15 Projekte für die Anfänger.
Dies ist die neue Sunfounder Starter Kit, das speziell für diesen Anfänger, die daran interessiert sind Arduino entwickelt.
Ein kompletter Satz von Arduino die häufigsten und nützliche elektronische Komponenten.
Ausführliche Anleitungen (44 Seiten Projektbroschüre und Micro DVD) einschließlich der Projekteinführung und deren Quellcode wird mit dem Kit zum Nulltarif.

Der ARDUINO UNO R3 ist NICHT enthalten

15 Projects for beginner
Lesson 1 Button1
Lesson 2 LED Flowing Lights
Lesson 3 Buzzer
Lesson 4 Photoresistor
Lesson 5 RGB LED
Lesson 6 Relay
Lesson 7 Tilt-Switch
Lesson 8 Servo
Lesson 9 LCD1602
Lesson 10 Thermistor
Lesson 11 Voltmeter
Lesson 12 Ultrasonic
Lesson 13 Stopwatch
Lesson 14 Automatic Light Source Tracking
Lesson 15 Backing a Car

Package included
1x  1602 LCD Module
1x  USB Cable
1x  Breadboard
20x Female to Female Dupont Wire
40x Male to Male Dupont Wire
1x  Project Box
8x  Resistor - 220R
4x  Resistor - 1 kR
4x  Resistor - 10 kR
4x  Resistor - 100 kR
1x  Resistor - 1 MR
1x  Resistor - 5.1 MR
1x  Ultrasonic
1x  Ultrasonic holder
1x  4 digit 7 segment
2x  NPN Transistor
1x  FET Power Transistor
2x  Diode (Rectifier)
1x  Diode (Zener)
1x  Motion Sensor (Tilt Switch)
1x  Light Sensor (Photocell)
1x  Temperature Sensor
2x  Button
2x  Rotary Knob (Potentiometer)
1x  Servo Motor
1x  RGB LED
4x  Green LED
4x  Red LED
4x  Yellow LED
1x  Piezo Buzzer/Speaker
1x  Relay
80x Pin Header
1x  Booklet   
Ausführliche Anleitungen (44 Seiten Projektbroschüre und Micro DVD)


http://www.elektor.com/ultrasonic-kit-for-arduino
http://www.sunfounder.com/index.php?c=show&model=Ultrasonic Kit&id=21

Nun sei noch angemerkt, dass es natürlich auch eine Menge weiterer Arduino Starter Kits gibt. Bezugsquellen dafür und auch für die Beschaffung von Einzelteilen gibt es hier:

http://www.arduino-tutorial.de/




*********************************************************
Make: BUCH
                    Making Things Talk

http://www.tutorialspoint.com/arduino/

505_d_Sensor-x_Arduino - Learning - TUTORIAL (711 Seiten)_1a.pdf

INHALTSVERZEICHNIS des 711 Seitigen ARDUINO - Learning -TUTORIAL


Blink § LED  s.8
Button § Taster s.11
Loop § 6x LEDs s.15
Analog Input § Poti 10k s.17
Knock § Piezo-Lautsprecher s.20
Dimmer § s.25
Graph § s.27
Virtual Color Mixer § RGB LED s.31
Read Two Switches § 2xTaster s.33
Tilt Sensor § Tilt s.35
Joystick LED Lauflicht § Joystick 8x LED s.36
Stopwatch § s.43
ADXL3xx Accelerometer § ADXL320  321 322 330 s.45
Memsic 2125 Accelerometer § Memsic 2125  s.47
PING ))) § HC-SR04  s.50
QT401 Sensor § QT401 s.53
Play Melody § Piezo-Lautsprecher s.47
LED Driver § 8xLED s.62
LCD Display 8-bit § s.64
Arduino Liquid Crystal Library LCD Interface § HD44780 s.67
Unipolar Stepper Motor § Schritt-Motor Pot.10k ULN2003A  s.71
Arduino Software Serial Interface

s.77
RS-232 driver/receiver § MAX3323E         s.82
Interfacing a Serial EEPROM Using SPI § AT25HP512 s.89
Controlling a Digital Potentiometer Using SPI § AD5206      s.96
Serial to Parallel Shifting-Out with § 74HC595 16xLED s.103
X10 Library § PL513 TW523 s.100
Examples

s.136
First Sketch

s.139
Pins

s.141
Analog Pins

s.142
PWM

s.143
Memory

s.145
Bootloader

s.146
Variables

s.147
Tutorial.Foundations History

s.150
Tutorial.Links History

s.157
The "Hello World!" of Physical Computing

s.186
Knight Rider § 6xLED s.174
Shooting Star § 11xLEDs s.178
Pushbutton § Taster s.181
Switch § Taster s.183
Reading a Potentiometer (analog input) § Pot-10k s.185
Interfacing a Joystick § Joystick 2xPot10k s.187
Knock Sensor § Piezzo-Ls s.190
Parallel to Serial Shifting-In with § CD4021BE s.185


  Ultraschallsensor-Modul HC-SR04

Bauteile 03.11.2014, 19:06 von Fritz Prenninger

... 13,89 http://www.exp-tech.de/Sensoren/SRF02-Ultraschall-Entfernungssensor.html 085 BB HC-SR04 Ultraschallsensor HC-SR04 - Ultrasonic Module HC-SR04 Fa. Funduino 086 BB HC-SR04 US ...

Starter-Kit & Lern-Set 22.01.2015, 14:52 von Fritz Prenninger

... Batterieklemme auf 2,1mm Hohlbuchse) zum Anschluss von 9Vdc Transistor-Batterien 1x US-Modul HC-SR04 mit zwei Ultraschallsensor 45x20mm (US-Transceiver-Modul DYP-ME007) 1x PIR-Bewegungsmelder HC-SR501 ...

Starter-Kit & Lern-Set

AVR-uC und BASCOM 08.11.2014, 12:49 von Fritz Prenninger

... Force Sensing Resistor http://datenblaetter.physicalcomputing.at/fsrguide.pdf SRF02  US-Sensor, Abstands-Sensor HC-SR04 oder DYP-ME007  Ultraschall-Transceiver Modul Grove - Ultraschallentfernungssensor SHS A2  Feuchte-Sensor IC Alkohol ...

AVR-uC und BASCOM

Elektronik-Bauteile 11.08.2014, 13:38 von Fritz Prenninger

... http://datenblaetter.physicalcomputing.at/fsrguide.pdf US-Sensor, Abstands-Sensor SRF02 Ultraschall-Transceiver Modul HC-SR04 oder DYP-ME007 Grove - Ultraschallentfernungssensor Feuchte-Sensor IC SHS A2 Alkohol - Gas Sensor Kohlenmonoxid ...

AVR-uC und BASCOM ‎>‎ Elektronik-Bauteile

SKETCH 05.11.2014, 18:37 von Fritz Prenninger

... vergrößert.  */ // Titel:  3.8 Der Bewegungsmelder - Wärme-Melder mit Buzzer // Beschreibung: Bewegungsmelder PIR-Modul HC-SR501 // Autor: Fritz Prenninger // Datum: 2014-09-25 // Sketch: _3_8_Der_Bewegungsmelder_mit_PIR ... dann piepse nicht   }   tempC=0; } // Titel:  3.10b Entfernung messen mit US-Modul HC-SR04 und Buzzer // Beschreibung: Abstand messen 2cm bis 5m // Autor: Fritz Prenninger // Datum: 2014-09-26 ...

SKETCH

Anleitung-Tutorial 05.01.2015, 15:41 von Fritz Prenninger

... parallax_ping.pdf 5.13 Ultraschall-Entfernungsmesser (2 cm bis 4 m) § Cytron Technologies HC-SR04  datasheets/HC-SR04_user_manual.pdf,  http://tutorial.cytron.com.my/tag/hc-sr4 ...

Anleitung-Tutorial


US-Sensor-Modul  MaxBotix LV-EZ-1







*********************************************************
          Einpark-Hilfe mit Ultraschall-Transceiver-Modul.
               Elektronik, die Audiosignale mit 40 kHz sendet und empfängt.
Durch die Messung der Zeit zwischen Trigger-Impuls und Echo kann man sehr einfach die Entfernung berechnen.

Ampel mit
                O   ROT
                O   GELB
                O   GRÜN


Die Schaltung kommt mit drei LEDs zur Anzeige der Distanz aus.
Die grüne LED signalisiert, dass das Auto noch zu weit weg von der Wand ist.
Die gelbe LED zeigt die richtige Stoppposition an.
Leuchtet die rote LED, ist man schon zu nahe an der Wand und sollte besser ein Stückchen vorziehen.
Insgesamt werden von der ParkHilfe sieben Entfernungen mit drei LEDs signalisiert:

• Grünes Dauerleuchten signalisiert eine große Entfernung und bedeutet, dass man näherkommen kann.
• Die grüne LED blinkt, wenn man näher als 32“ (ca. 80 cm) ist.

• Die grüne und die gelbe LED leuchten dauernd, wenn man 24“ 
(ca. 60 cm) von der Zielposition entfernt ist. Man sollte langsam anhalten.
• Das Erreichen der Zielposition wird durch gelbes Dauerlicht signalisiert. Die Zielzone ist etwa
16“  (ca. 40 cm) groß.
• Leuchten die gelbe und die rote LED, verlässt man die Zielposition.
8“  (ca. 20 cm)  Man sollte dann etwas zurücksetzen.
• Leuchtet die rote LED alleine, ist man schon über die Zielposition hinaus.
4“  (ca. 10 cm)  Das sollte man korrigieren.
• Eine blinkende rote LED bedeutet, dass man schon viel zu nahe an der Wand steht.
2“  (ca. 5 cm)
Man sollte sofort anhalten und zurücksetzen oder man zerstört das Gerät das Auto und mehr.


Mit Hilfe dieser Ampel kann man sehr einfach replizierbar und genau einparken.
Dies zu erreichen ist mit Software sehr einfach.
Rein in Hardware wäre das sehr viel schwieriger.
Außerdem können dank Software die Entfernungen sehr leicht geändert werden und per geänderter Firmware in den Mikrocontroller übertragen werden.







*********************************************************
                    z.B. Ch.45 - Ultrasonic Sensors
           Tutorial - Parallax Ping))) Ultraschall-Sensor


Sense Abstand mit Ultraschall-Sensoren im Kapitel 45 einer Reihe ursprünglich mit dem
Titel "Erste Schritte / Moving Forward mit Arduino!" Von John Boxall

- einer Reihe von Artikeln über Arduino.
http://tronixstuff.com/tutorials/
Das erste Kapitel ist da, die komplette Reihe wird hier beschrieben.
http://tronixstuff.com/2010/04/04/getting-started-with-arduino-chapter-zero/

Aktualisiert 2013.05.02

Während ein Passagier in einem Fahrzeug mit einem "Rückfahrsensoren", wurde ich etwas neugierig, wie die Sensoren betrieben und wie können wir sie nutzen.
Also, für dieses Kapitel werden wir einen Ultraschallsensor von Parallax untersuchen namens Ping)))  Ultraschall-Abstandssensor.
https://www.parallax.com/product/28015
Er kann Abstände zwischen ~ 2cm und ~ 3m Länge messen.

Hier ist der Beispiel-Sensor:


Parallax haben eine Menge Arbeit zu erledigen, enthält das Board nicht nur die nackten Sensor-Hardware aber Controllerschaltung sowie:



Das ist toll, denn es lässt uns mit nur drei Pins - 5V, GND und Signal.
Mehr zu den in einem Moment, aber zuerst ...

Wie funktioniert das?

Gute Frage.
Das Gerät sendet einen Ultraschall (einen Sound, der eine Frequenz, die höher als die vom menschlichen Ohr gehört werden muss) brach der Klang von einem Wandler (die runden Silber Dinge) und wartet auf sie abprallen ein Objekt und zurück - das ist, von dem anderen Wandler detektiert.
Der Vorstand wird dann an uns zurücksenden die Zeit für diesen Prozess zu übernehmen, die wir interpretieren kann, um den Abstand zwischen dem Sensor und dem Objekt, von dem das Ultraschall erholte sich von zu bestimmen.

Das Ping-))) misst nur eine Entfernung, wenn angefordert -, dies zu tun, schicken wir eine sehr kurze HOCH Impuls von fünf Mikrosekunden an den Signalstift.
Nach kurzer Zeit wird ein Impuls von der Platine auf der gleichen Signalstift kommen.
Die Laufzeit dieser zweiten Impuls ist die Zeit, die der Klang nahm zu reisen hin und zurück vom Sensor - so teilen wir es mit zwei, um den Abstand zu berechnen.
Schließlich, da die Schallgeschwindigkeit ist 340 Meter pro Sekunde, die Arduino Sketch kann den Abstand auf das, was erforderlich Einheiten zu berechnen.

Es klingt vielleicht kompliziert, aber es ist nicht - also lassen Sie uns durch die Theorie der Arbeitsweise an einem Beispiel auszuführen.
Mit unserem digitalen Speicher oscillscope wir die Wellenformen auf der Signalstift während einer typischen Messung wurden gemessen.
Betrachten Sie das folgende Beispiel für Messen einer Entfernung von 12 cm:

fulltwelvecm

Sie können die 5US Impuls in der Mitte und den Impuls von der Sensorplatine rechts zurück sehen.
Jetzt zum Vergrößern auf das zurück Impuls:

twelvecm

Ohne zu wählerisch der Puls ist etwa 720uS (Mikrosekunden) lang - die Dauer der Ultraschall der Rückfahrt von der Sensorplatine.
So teilen wir dies durch zwei, um die Zeit, um die Strecke zurückzulegen finden - 360uS.
Daran erinnern die Schallgeschwindigkeit ist 340 Meter pro Sekunde - die 29,412 pro Zentimeter verwandelt uns.
Also, 360uS geteilt durch 29,412 gibt uns 12,239902081 ... Zentimeter. Gerundet, die uns 12 Zentimeter.

Schließlich gibt es einige Einschränkungen, um mit Hilfe der Ping))) Sensor.
Laden Sie das Datenblatt (pdf) und lesen Sie drei vor fünf Seiten für Informationen darüber, wie Sie den Sensor und die Empfindlichkeit resultiert aus Fabrik Ruhe effektiv zu montieren.

Wie verwenden wir es mit Arduino?


Wie zuvor beschrieben, müssen wir zunächst eine 5uSek. Impuls senden, dann warten Sie auf das Rückkehrimpuls.
Die folgende Skizze ist nur so, dass, dann wandelt die Daten in Zentimetern und zeigt das Ergebnis auf der seriellen Monitor.
Der Code / Sketch / Programm  wurde kommentiert, und jeder Schritt erklärt.

45.1 Entfernung messen mit Ultra-Schall-Modul PING)))_1a.ino

// Titel: 45.1 Entfernung messen mit Ultra-Schall-Modul PING)))
// Beschreibung: Abstand messen 2cm bis 5m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: 45.1 Entfernung messen mit Ultra-Schall-Modul PING)))_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// Beispiel 45.1 - Parallax Ping))) Ultrasonic Sensors 
// www.tronixstuff.com

int signal=8;   // verbinde Parallax Ping))) Signalstift in digitale pin-8 ARDUINO
int distance;
unsigned long pulseduration=0;

void setup(){
  pinMode(signal, OUTPUT);
  Serial.begin(9600);
}
void measureDistance(){

  pinMode(signal, OUTPUT);            // setze pin-8 als Ausgang, so dass wir einen Impuls senden
  digitalWrite(signal, LOW);          // setze Ausgabe auf LOW
  delayMicroseconds(5);               // jetzt senden 5uSek. Impuls aus, um PING))) zu aktivieren

  digitalWrite(signal, HIGH);
  delayMicroseconds(5);
  digitalWrite(signal, LOW);
  pinMode(signal, INPUT);              // den pin-8 auf Eingeben ändern, um den ankommenden Puls lesen zu können
  pulseduration=pulseIn(signal, HIGH); // mißt die Länge des Eingangsimpulses
}

void loop(){
  measureDistance(); // wir erhalten die rohen Messdaten (WERT) von PING)))
  pulseduration=pulseduration/2;       // die Impulslänge auf die Hälfte zu teilen da ja Laufzeit hin und zurück ist
  distance = int(pulseduration/29);    // nun Laufzeit in Zentimeter umzuwandeln
  Serial.print("Distance - ");         // Anzeige auf serielle Monitor in cm
  Serial.print(distance);
  Serial.println(" cm");
  delay(500);                          // Wartezeit 0,5 Sekunden
}

Und die Ergebnisse einiger Handschwingen im seriellen Monitor:


So dort haben Sie es - Sie können nun messen Abstand mit einer Genauigkeit.
Jedoch, dass Bild oben ist nicht sehr aufregend - verwenden eine 7-Segment-Anzeige Schild, http://tronixstuff.com/2011/08/24/review-gravitech-7-segment-arduino-shield/
Dinge in Lichter bekommen anstatt lassen.
Der Schirm nutzt die  NXP SAA1064 LED-Display-Treiber-IC (hier erklärt ganz gut). http://www.nxp.com/products/lighting_driver_and_controller_ics/dc_powered_led_drivers/i2c_led_display_control/SAA1064_CNV.html

Sie können die Demo-Skizze hier herunterladen. http://tronixstuff.com/2011/07/21/tutorial-arduino-and-the-nxp-saa1064-4-digit-led-display-driver/

Und jetzt  das Video:

So dort haben Sie es - jetzt die Verwendung des Sensors bis zu Ihrer Phantasie.
Stay tuned mit den Methoden aus, um zu sehen, was wir bis zu diesem Sensor in der Zukunft.

John Boxall
Gründer, Inhaber und Chefredakteur von www.tronixstuff.com
http://tronixstuff.com/2011/11/28/tutorial-parallax-ping-ultrasonic-sensor/




*********************************************************
Die Arduino-Referenz zu pulseIn: http://www.arduino.cc/en/Reference/PulseIn  NICHT pulseln

Von www.schaltungen.at downloadbar
Was ist beim Programmieren des wesentlich billigern 4-Pin HC-SR04 zum ORIGINAL 3-Pin Parallax PING))) Ultrasonic Sensor zu beachten ! ! !
084_d_elePOST-x_Nr.13 120462-11 ParkHilfe 40kHz US-Transceiver-Modul § HC-SR04 PIC16F690_1a.pdf
505_d_Sensor-x_HC-SR04 Ultraschall Messmodul - Beschreibung_1a.pdf
505_d_Sensor-x_140209-11 Pegel- und Distanzmessgerät § US-Sensor HC-SR04 US-020 SRF02_1a.pdf







*********************************************************
1. BUCH: Sensoren  S.047 Entfernung messen

505_d_Sensor-x_Entfernung mit Ultraschall messen (1) § US-Sensor PING)))_1a.pdf
505_d_Sensor-x_Entfernung mit Ultraschall messen (2) § Ultraschallsensor HC-SR04_1a.pdf
505_d_Sensor-x_Entfernung mit Ultraschall messen (3) § US-Sensor Echoberechnungen_1a.pdf





*********************************************************
2. BUCH: Die elektronische Welt mit Arduino entdecken  S.543  Das Tisch-Sonal  180° Ultraschal-Abtastung PARALLAX PING))) mit Processing-Anzeige
www.parallax.com   Scan-Angle 0 bis 180°  Distance:  3,0cm bis 3,0m
505_d_Sensor-x_Das Tisch-Sonar (1) § US-Sensor PING)))_1a.pdf
505_d_Sensor-x_Das Tisch-Sonar (2) § Sketch US-Sensor PING)))_1a.pdf
505_d_Sensor-x_Das Tisch-Sonar (3) - Visualisierung mit Processing_1a.pdf
505_d_Sensor-x_Das Tisch-Sonar (4) - PING))) Servo SG90 9g (Tower Pro)_1a.pdf






*********************************************************
3. BUCH: Arduino Kochbuch  S.192  Abstände messen mit Ultraschall-Sensor Parallax PING)))
2cm sehr scnelle Blinkgeschwindigkeit  3m sehr langsame Blinkgeschwindigkeit
oder MaxBotix EZ1 / MaxSonar ultrasonic
Ultraschall Entfernungsmesser MB1010 LV-MaxSonar-EZ1
http://www.adafruit.com/products/172
http://playground.arduino.cc/Main/MaxSonar
http://www.maxbotix.com/articles/085.htm
http://www.maxbotix.com/tutorials.htm
"505_d_Sensor-x_Abstände messen (1) § US-Sensor PING)))_1a.pdf"

Abstände mit Infrarotsensoren genau messen  
SHARP IR Range Finder
Sharp 20-150cm Infrared Distance Sensor
https://www.tindie.com/products/upgradeindustries/sharp-20-150cm-infrared-distance-sensor-gp2y0a02yk0f-/
https://www.sparkfun.com/products/8958
http://www.societyofrobots.com/sensors_sharpirrange.shtml
"505_d_Sensor-x_Abstände genauer messen (2) § IR-Sensor SHARP GP2Y0A02YK0F_1a.pdf"




*********************************************************
(1A)
4. BUCH: Arduino dpunkt-Verlag  S.080  Entfernung mit einem Ultraschallsensor messen
Parallax PING)))
US-Sensor PING))) mit Temperatur-Kompensation TMP36 (oder LM35 Z)
http://www.analog.com/en/products/analog-to-digital-converters/integrated-special-purpose-converters/integrated-temperature-sensors/tmp36.html
https://www.parallax.com/product/28015
https://www.parallax.com/downloads
http://makezine.com/2009/10/15/using-sonar-to-save-power/


505_d_Sensor-x_PING))) Ultrasonic Distance Sensor (#28015) - Product-Guide-v2.0 (Datenblatt)_1a.pdf
505_d_Sensor-x_Smart Sensors and Applications - Student Guide v1.0 (Ping))) US-Sensor (340 Seiten)_1a.pdf

505_d_Sensor-x_Entfernung messen (1) § US-Sensor PING))) TMP36_1a.pdf
505_d_Sensor-x_Entfernung messen (2) § Sketch US-Sensor PING))) TMP36_1a.pdf
505_d_Sensor-x_Entfernung messen (3) - Genauigkeit mit Fließkommazahlen erhöhen_1a.pdf
505_d_Sensor-x_Entfernung messen (4) - Genauigkeit mit Temperatur-Sensor TMP36 erhöhen_1a.pdf
505_d_Sensor-x_Entfernung messen (5) - Sketch PING))) TMP36_1a.pdf





*********************************************************
5. BUCH: Arduino Schaltungsprojekte für Profis  S.122  Distanzmessung mit 40kHz Ultraschall-Kapseln
UltraSonic RADAR

Ultraschall Entfernungsmesser mit I2C,
US-Sender und US-Empfänger
MONACOR  Ultraschall-K-Kapsel  UST-40R Best.-Nr.: 231230

Ultraschall-Keramik-Kapseln

 in hoher Qualität, verwendbar als US-Mikrofon (Receiver UST-40R) oder als Signalgeber (Transmitter UST-40T), z.B. für Alarmanlagen.
http://shop.monacor.at/product_info.php/info/p5332_Ultraschall-K-Kapsel.html

SRF02 Ultrasonic Sensor

http://www.maxbotix.com/
SRF02 - Low Cost, High Performance Ultraschall Entfernungssensor
Noch recht wenig bekannt ist der neue kompakte Ultraschallsensor SRF02.
Dieser Sensor stellt eine preiswerte Alternative zu den Sensoren SRF05 oder SRF10 dar, kann jedoch keine kleineren Entfernungen als 15 cm messen.
Allerdings reicht der Messbereich von 15cm bis ca. 6m durchaus für viele Anwendungen aus.

http://www.exp-tech.de/srf02-ultrasonic-ranger
http://rn-wissen.de/wiki/index.php/Ultraschallsensor_SRF02_am_RN-Board


SRF02 Ultraschall Entfernungssensor EXP Tech Nr. EXP-R11-002

http://www.exp-tech.de/srf02-ultrasonic-ranger
https://github.com/grappendorf/arduino-framework/tree/master/SRF02
http://www.robot-electronics.co.uk/htm/arduino_examples.htm
http://www.instructables.com/id/Introduction-14/?lang=de
http://www.instructables.com/id/How-to-make-a-simple-ultrasonic-radar-system-/?lang=de (0 bis 180°)
http://www.academia.edu/5342277/Arduino_based_Ultrasonic_RADAR
https://github.com/indiejoseph/Radar
https://github.com/JRodrigoTech/Ultrasonic-HC-SR04


Daten vom Ultraschallsensor SRF02 als Grafik ausgeben

http://www.roboternetz.de/community/threads/62321-Daten-vom-Ultraschallsensor-SRF02-als-grafik-ausgeben
https://technikgreek.wordpress.com/author/technikgreek/


505_d_Sensor-x_Distanz messen (0) § US-Sender und US-Empfänger SRF02 UltraSonic RADAR_1a.pdf





*********************************************************
6. BUCH: Marking Things Talk 
S.268  IR-Entfernungsmessung mit SHARP GP2Y0A21YK
  10..80cm
S.270  US-Entfernungsmessung mit MaxBotix LV-EZ1 Ultraschall-Ranger
LV-MaxSonar-EZ
XL-Max Sonar-EZ

http://www.maxbotix.com/

https://books.google.at/books?id=iROuAgAAQBAJ&pg=PA270&lpg=PA270&dq=maxbotix+lv-ez1+arduino&source=bl&ots=2gd3k-KVlR&sig=M7IWgnSXPr4pQ-QVjIScoakjM5E&hl=de&sa=X&ei=FZAvVaqSJML2avPwgOAC&ved=0CFwQ6AEwCDgK#v=onepage&q=maxbotix%20lv-ez1%20arduino&f=false
http://www.maxbotix.com/tutorials.htm
http://playground.arduino.cc/Main/MaxSonar



Ultrasonic Range Finder - LV-MaxSonar-EZ1 SEN-00639
https://www.sparkfun.com/products/639
http://www.instructables.com/id/Getting-started-with-the-Maxbotix-sonar-sensor-q/
http://physicalcomputing.at/Ultraschall-Entfernungssensor


MaxBotix LV-EZ1 Ultraschall-Ranger

Ultraschall-Entfernungsmesser - MaxBotix LV-EZ1


Die serielle Schnittstelle ist ein wenig seltsam (es \ 's RS232 anstelle von Standard-TTL), aber die PWM-und Analog-Schnittstellen ermöglicht allen Mikro zu leicht genug zu hören.
Der Sensor liefert sehr genaue Messungen von 0 bis 255 cm (0 bis 6,45 m) in 1-Zoll-Schritten mit wenig oder gar keine tote Zone!

Maxbotix bietet den EZ0, EZ1, EZ2, EZ3 und EZ4 mit immer schmaler Abstrahlwinkel so dass der Sensor, um die Anwendung anzupassen.

MaxBotix Ultraschall Entfernungssensor - MB1010 LV-MaxSonar-EZ1

http://www.exp-tech.de/maxbotix-ultrasonic-range-finder-mb1010-lv-maxsonar-ez1

https://www.tinkersoup.de/abstand-proximity/ultrasonic-range-finder-maxbotix-lv-ez1/a-248/

505_d_Sensor-x_Infrarot-Entfernungsmessung § SHARP GP2Y0A21_1a.pdf
505_d_Sensor-x_Ultraschall-Entfernungsmessung § MaxBotix LV-EZ1_1a.pdf

505_d_Sensor-x_US-Entfernungsmessung LV-MaxSonar-EZ Datasheet § MaxBotix LV-EZ1_1a.pdf





*********************************************************
7. BUCH: Arduino Praxiseinstieg    
S.197  US-Abstandssensor 
Ultrasonic Sensor von Parallax PING)))


S.198   IR-Abstandssensor  SHARP Infrared Proximity-Sensor GPD2D120

Kapitel 5  Sensoren, Aktoren, Anzeigen
5.1.8 Abstandssensoren
Abstandssensoren gehören zur Grundausstattung eines mobilen Roboters und erfassen den Abstand zu den Gegenständen, die sich in seiner Reichweite befinden.
Methoden und Technologien zur Messung des Abstands vom Sensor gibt es viele. Je nach Anforderung muss ein genauer Wert vom Abstand des Gegenstands, ein großer Bereich oder nur ein Status ermittelt werden. Entsprechend den Anforderungen sind die Sensoren recht unterschiedlich.

Ultraschallsensoren
:
Ein Ultraschallsensor sendet ein Signal (Schall), das oberhalb des menschlichen Hörbereichs liegt. Trifft der Schall auf einen Gegenstand, so wird das Signal zurückgeworfen und vom Sensor wieder empfangen. Die Verzögerungszeit zwischen dem Senden und dem Empfangen des Signals entspricht dem Abstand des Gegenstands zum Sensor. Bekanntlich ermitteln die Fledermäuse in der Natur auf diese Art die Umwelt und die Objekte um sie herum.

Der vermutlich bekannteste Ultraschallsensor in der Arduino-Welt ist der
PING))) Ultrasonic Sensor von Parallax  http://www parallax.com
Der auf einer Leiterplatte aufgebaute Sensor sendet ein Signalpaket aus und empfängt anschließend das Echo des Signals.

Das Tutorial auf der Arduino-Website
http://arduino.cc/en/Tutorial/Ping
http://www.arduino.cc/en/Tutorial/Ping
zeigt die Verdrahtung des Sensors sowie ein Beispielprogramm für die Ermittlung des Abstands.
Der Arduino sendet ein Signalpaket und mit dem Befehl pulseIn()  wird die Dauer bis zum Empfang des Echos gemessen.
Bei einer Schallgeschwindigkeit von 340 m/s oder 29 Mikrosekunden pro cm kann mit einer einfachen Formel die Distanz ermittelt werden:

Abstand in cm = gemessene Zeit / 29 * 2

Die Division durch 2 ergibt sich dadurch, dass Hin- und Rückweg des Schalls gemessen wurden.
Der PING-Sensor ist eine praktische Sensorlösung für Roboter, um entfernte Gegenstände zu erfassen.
Er arbeitet gemäß Hersteller in einem Bereich von 2 bis 3oo cm.


Sketch

 Ping))) Sensor ORIGINAL                              
 

Diese Sketch liest einen PING))) Ultraschall-Entfernungsmesser und gibt den Abstand zum nächsten Objekt in cm aus.
Um dies zu tun
, einen Impuls sendet sie an den Sensor, um eine Ablesung zu initiieren, wartet dann ein Impuls zur Rückkehr.
Die Länge des
Zurückimpulses ist proportional zum Abstand des Gegenstandes von dem Sensor.

Die Schaltung
:
 +V Anschluss des PING))) auf +5V
GND Anschluss des
PING))) mit Masse verbunden
SIG Anschluss des PING))) auf digitale Stift pin-7


http://www.arduino.cc/en/Tutorial/Ping
erstellt
     3. November 2008  von David A. Mellis
modifiziert
30. August   2011  von Tom Igoe

Dieses Beispiel
-Code ist in der Public Domain.



ORIGINAL Parallax Ping))) Ultraschall-Entfernungsmesser_1a.ino

// Titel: Parallax Ping))) Ultraschall-Entfernungsmesser
// Beschreibung: Abstand messen 2cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: ORIGINAL Parallax Ping))) Ultraschall-Entfernungsmesser_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// Parallax Ping))) Ultraschall-Entfernungsmesser
// Ping Ultrasonic Range Finder (1A) ORIGINAL
// http://www.arduino.cc/en/Tutorial/Ping

const int pingPin = 7; // Diese Konstante wird sich nicht ändern, es ist der Pin-7 des Sensors Anschlusses

void setup() {
  Serial.begin(9600);  // Initialisierung der seriellen Kommunikation
}     

void loop(){
  long duration, inches, cm;  // Variablen zur Laufzeit der Ping zu etablieren 
  // und der Abstand Ergebnis in Zoll und Zentimeter
  // Der PING))) wird mit einem High Impuls von 2 Mikrosekunden oder mehr ausgelöst.

  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);  // kurze 2ms LOW Impuls vorausgeben, um eine saubere HIGH-Puls zu gewährleisten
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);  // Der PING))) wird mit einem High Impuls von 5 Mikrosekunden oder mehr ausgelöst.
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  // Der gleiche Pin zum Anzeigen des Signals von dem PING)))  lesen: HIGH
  // Dessen Dauer ist die Zeit (in Mikrosekunden) von der sendet
  // der Ping auf den Empfang sein Echo von einem Objekt.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  inches = microsecondsToInches(duration);
  cm = microsecondsToCentimeters(duration);  // Zeit in einem Abstand in cm  konvertieren

    Serial.print(inches);
  Serial.print("in, ");
  Serial.print(cm);
  Serial.print("cm");
  Serial.println();
  delay(100);
}

long microsecondsToInches(long microseconds){
  // Nach Parallax Datenblatt für den PING))) braucht es
  // 73,746 Mikrosekunden pro Inch (d.h. Schall bei 1130 Fuß pro Sekunde)
  // Dies gibt den Abstand vom PING))), Outbound gereist
  // und zurück, so dass wir durch 2 teilen, um den Abstand zum Hindernisses zu bekommen.
  return microseconds / 74 / 2;
}

long microsecondsToCentimeters(long microseconds){
  // Die Schallgeschwindigkeit beträgt 340m/s oder 29 Mikrosekunden pro Zentimeter.
  // Der Ping läuft hin und zurück, so, um den Abstand von der zu finden
  // Objekt nehmen wir die Hälfte der zurückgelegten Strecke.
  return microseconds / 29 / 2;
}


http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
https://www.parallax.com/sites/default/files/downloads/28015-PING-Detect-Distance.pdf
https://www.parallax.com/sites/default/files/downloads/28015-PING-Sensor-Product-Guide-v2.0.pdf
https://www.parallax.com/sites/default/files/downloads/28015-PING-Documentation-v1.6.pdf





Infrarotsensor Sharp GP2Y0A21YK0F IR distance sensors.

Sharp GP2Y0A21YK0F Analog Distance Sensor 10-80cm
https://www.pololu.com/product/136
http://www.robotroom.com/DistanceSensor.html
https://www.pololu.com/search/compare/79
https://www.pololu.com/search/compare/162


Die Beziehung zwischen der Ausgangsspannung des Sensors und dem Kehrwert der gemessenen Entfernung ist in etwa linear über nutzbare Bereich des Sensors.
Reichweite (10-80 cm) GP2Y0A21YK0F
300_d_SHARP-x_GP2Y0A21YK0F  Infrarot Distanz Sensor 10 bis 80cm (Datenblatt)_1a.pdf
 enthält eine grafische Darstellung der analogen Ausgangsspannung als Funktion des Kehrwerts Abstand zu einem reflektierenden Objekt.

Sie können diese Darstellung zu verwenden, um die Sensorausgangsspannung auf einen ungefähren Abstand durch die Konstruktion eines Best-Fit-Linie, die das Inverse von der Ausgangsspannung (V), um die Entfernung (cm) betrifft konvertieren.
In seiner einfachsten Form kann der Linearisierungsgleichung sein, dass die Entfernung zu dem reflektierenden Objekt ungefähr gleich einem konstanten Skalenfaktor (~ 27 V * cm) geteilt durch die Ausgangsspannung des Sensors ist.
Hinzufügen eines konstanten Abstand versetzt und Änderung des Skalierungsfaktors die Passform dieses Linie zu verbessern.
Alternative Sharp Abstandssensoren

Wir haben eine Vielzahl von Sharp Abstandssensoren zur Auswahl, darunter die
kürzerer                   Reichweite (4-30 cm) GP2Y0A41SK0F
und größerer Reichweite (20-150 cm) GP2Y0A02YK0F

Diese analogen Abstandssensoren haben ähnliche Pakete und identische Pin-outs, macht es einfach, eine Version für ein anderes sollten die Anforderungen Ihrer Anwendung verändern zu tauschen.

Wir führen auch die neuere Sharp GP2Y0A60SZ Analog-Abstandssensor (10 bis 150 cm), das die andere analoge Sharp Abstandssensoren in nahezu jeder Hinsicht übertrifft, die eine niedrige Mindesterfassungsabstand, hohe maximale Erfassungsabstand, breite 3 V Ausgangsspannungsdifferenz, hohe
60Hz Abtastrate, Betrieb auf 2,7V und optional Freigabesteuerung, die alle in einem kleineren Gehäuse.

Für sehr kurze Bereichserfassungsanwendungen, führen wir eine 2-15 cm analoge Sharp Abstandssensor.
Wir führen auch
drei digitale Sharp Abstandssensoren, die niedrige Mindesterfassungsreichweiten und eine hohe Aktualisierungsrate 400Hz haben.
Sie sind mit
einem 5 cm, 10 cm oder 15 cm Reichweite und einfach sagen, wenn etwas in ihrem Erfassungsbereich, nicht, wie weit es ist. Sie sind kleiner als die analogen Sharp Abstandssensoren und weniger Strom.


Infrarotsensoren für die Abstandsmessung versenden ein Lichtsignal im Infrarotbereich und empfangen die am Gegenstand reflektierten Lichtwellen wieder.
Roboteranwendungen mit Arduino verwenden oftmals den
Infrared-Proximity-Sensor GPD2D120 von Sharp.
Dieser Infrarotsensor hat einen Analogausgang, der direkt vom angeschlossenen Arduino-Board ausgewertet werden kann.
Die Ausgangsspannung liegt im Bereich von 3 Volt (3 cm Abstand) und 0,3 Volt (40 cm Abstand).
Der Sensor kostet rund € 14,-  und ist bei verschiedenen Elektronikhändlern erhältlich.
Ein praktisches Beispiel, wie der Abstandssensor eingesetzt werden kann, zeigt die Abstandsvisualisierung mit Infrarotsensor:


Visualizing Sensor Data with Arduino and Processing
http://www.uchobby.com/index.php/2009/03/08/visualizing-sensor-with-arduino-and-processing/

Der vom Infrarotsensor erfasste Gegenstand im Erfassungsbereich wird optisch dargestellt.
Der Lösungsansatz kann ein Teil eines Roboters sein, der während der Fahrt die Umwelt im Bereich von 0 bis 180 Grad abfragt.
Das Beispiel zeigt auch, wie man über die serielle Schnittstelle Informationen ausgeben kann, die anschließend eine Visualisierungslösung, in diesem Fall Processing, darstellen kann.






*********************************************************
8. BUCH: Arduino Workshop    
S.271  IR-Sensoren zur Abstandsmessung
  IR-Sensor von SHARP GP2Y0A21YK0F

505_d_Sensor-x_Infrarot-Sensoren zur Abstandsmessung § SHARP GP2Y0A21YK0F_1a.pdf
505_d_Sensor-x_Kollisionen mithilfe eines IR-AbstandsSensors verhindern § SHARP GP2Y0A21_1a.pdf

S.274  US-Sensoren zur Abstandsmessung
US-AbstandsSensor Parallax PING)))

505_d_Sensor-x_UltraschalSensoren § Parallax PING))) 28015_1a.pdf
505_d_Sensor-x_Kollisionen mithilfe eines US-AbstandsSensors verhindern § Parallax PING))) 28015_1a.pdf
https://www.parallax.com/product/28015

Ultraschallsensoren für Kollisionvermeidung

http://www.generationrobots.com/de/content/65-ultraschallsensoren-f%C3%BCr-kollisionvermeidung
http://www.arduino.cc/en/Tutorial/Ping?from=Tutorial.UltrasoundSensor
http://playground.arduino.cc/Main/UltrasonicSensor

4-Pin Ultraschall- Modul HC-SR04 Abstand Messung

http://www.robodino.de/2011/12/ultraschall-distanz-sensor-hc-sr04.html

4-Pin Ultraschall- Modul HC-SR04 zur Abstand Messung_1a.ino

// Titel: 4-Pin Ultraschall- Modul HC-SR04 zur Abstand Messung
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: 4-Pin Ultraschall- Modul HC-SR04 zur Abstand Messung_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/*
 HC-SR04 Ping distance sensor
 Vcc to arduino 5,0V GND to arduino GND
 Echo to Arduino pin-13 Trig to Arduino pin-12
 */

#define trigPin 12           // Trigger pin-12
#define echoPin 13           // Echo pin-13

void setup() {
  Serial.begin (9600);       // Initialisierung der seriellen Kommunikation
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
}

void loop() {
  int duration, distance;
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(1000);    // High Impuls von 1000 Mikrosekunden
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;  // wegen hin und zurüch durch 2 teilen UND Schallgeschwindigkeit 29,1 us/cm
  if (distance >= 200 || distance <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distance);   // Ausgabe der Entfernung in cm
    Serial.println(" cm");
  }
  delay(500);                 // Wartezeit 0,5 Sekunden
}

Die Theorie dahinter:
Im obigen Programm wollen wir die Entfernung eines Objekts vor dem Ultraschallsensor zu berechnen.
Dieser Sensor kann ein "ping" zu einem bestimmten Zeitpunkt senden und empfangen, die Ping wieder auf die Beine an einem Objekt zu einem anderen Zeitpunkt.
Ein Ping ist nichts als ein Geräusch, das unhörbar für das menschliche hören ist und deshalb ist dieser Sensor "Ultraschall" bezeichnet.
Der Sensor schickt ein Ping zu einem Zeitpunkt t1 und empfangen das Aufprallen Ping zu einem Zeitpunkt t2.
Die Kenntnis der Schallgeschwindigkeit, die Zeitdifferenz delta t = t2 - t1 kann uns eine Vorstellung von der Entfernung eines Objekts.

Wenn beispielsweise delta t = 500 Mikrosekunden, wir wissen, es dauerte 250 Mikrosekunden für das Ping, ein Objekt getroffen und weitere 250 Mikrosekunden bis es zurück kommt.

Die ungefähre Schallgeschwindigkeit in trockene Luft wird durch die Formel:
c = 331,5 + 0,6 * [Lufttemperatur in Grad Celsius]
Bei 20 °C,   c = 331,5 + 0,6 * 20 = 343,5m/s

Rechnet man die Geschwindigkeit in Zentimeter pro Mikrosekunden erhalten wir:
c = 343,5 * 100/1 000 000 = 0,03435 cm/us
Der Abstand beträgt daher D = (delta t / 2) * c
oder D = 250 * 0,03435 = 8,6 cm

Anstelle der Verwendung der "Speed ​​of Sound", können wir auch die "Pace of Sound" zu verwenden.
Das Tempo des Schalles = 1 / Schallgeschwindigkeit = 1 / 0,03435 = 29.1 us/cm
In diesem Fall ist die Gleichung, um die Distanz nicht berechnet werden: D = (delta t / 2) /
"Pace of Sound"
und für das obige Beispiel: D = 250 / 29,1 = 8,6 cm

http://www.dx.com/p/arduno-37-in-1-sensor-module-kit-black-142834#.VTDETJP_HPI


Arduino mit Abstandssensor HY-SRF05


Einführung:
Das SRF05 ist ein evolutionärer Schritt von der SRF04 und wurde entwickelt, um die Flexibilität zu erhöhen, erhöhen Bereich und die Kosten weiter zu reduzieren.
Als solches ist das SRF05 vollständig kompatibel mit dem SRF04.
Die Reichweite wirde von 3 m auf 4 m erhöht.
Eine neue Betriebsart (Binden der Modus Pin mit Masse) kann die SRF05, um einen einzelnen Stift für beide Trigger und Echo verwenden und spart wertvolle Stifte auf dem Controller.
Wenn der Modus-Pin nicht angeschlossen, arbeitet das SRF05 mit separatem Trigger und Echo Stifte, wie das SRF04. Das SRF05 enthält eine kleine Verzögerung, bevor die Echoimpuls zu einem langsameren Controller wie der Basic Stamp und PICAXE Zeit, ihren Puls in Befehle ausführen zu geben.

Mode 1 - SRF04 kompatibel - Separate Trigger-und Echo-
Dieser Modus verwendet getrennten Trigger-Pin (Auslöser) und Echo-Pin und ist die einfachste Art zu bedienen.

Alle Code-Beispiele für die SRF04 wird für die SRF05 in diesem Modus.
Um diesen Modus zu verwenden, lassen Sie einfach den Modus Pin unbeschaltet - das SRF05 verfügt über einen internen Pull-up-Widerstand auf diesem Stift.

Connections for 2-pin Trigger/Echo Mode (SRF04 compatibel)



ARDUINO UNO mit Abstandssensor HY-SRF05 mit Ampel-Anzeige_1a.ino

ARDUINO_UNO_mit_Abstandssensor_HY-SRF05_mit_Ampel-Anzeige_1a.ino



// Titel: ARDUINO UNO mit 4-pin Abstandssensor HY-SRF05
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: ARDUINO UNO mit Abstandssensor HY-SRF05 mit Ampel-Anzeige_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


// ARDUINO Sonar mit Abstandssensor HY-SRF05

#define echoPin 3  // Echo Output ist pin-3 Eingang
#define trigPin 2  // Trigger Inputt ist pin-2 Ausgang

int rot = 8;       // LEDrot pin-8
int gelb = 9;      // LEDgelb pin-9
int gruen = 10;    // LEDgrün pin-10

void setup(){
  Serial.begin(9600);         // Initialisierung der seriellen Kommunikation
  pinMode(echoPin, INPUT);
  pinMode(trigPin, OUTPUT);
  pinMode(rot, OUTPUT);
  pinMode(gelb, OUTPUT);
  pinMode(gruen, OUTPUT);
}

void loop(){
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);       // kurzer 2ms LOW Impuls um einen sauberen HIGH-Puls zu gewährleisten
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);      // Der Ping wird mit einem High Impuls von 10us ausgelöst
  digitalWrite(trigPin, LOW);
  int distance = pulseIn(echoPin, HIGH);
  distance= distance/58;      // Abstand in cm  hin und zurück  2 x 29,1us/cm = 58,2us/cm
  Serial.println(distance);                    
  delay(100);                 // Pause 0,1 Sekunden

  if (distance <= 15) {                   // UGW
    digitalWrite(rot, HIGH);              // LED rot leuchtet wenn Abstand unter 15cm
    digitalWrite(gelb, LOW);
    digitalWrite(gruen, LOW);
  }
  if (distance <= 35 && distance > 15) {  // IO
    digitalWrite(rot, LOW);
    digitalWrite(gelb, HIGH);             // LED gelb leuchtet wenn Abstand zwischen 15cm und 35cm
    digitalWrite(gruen, LOW);
  }
  if (distance > 35) {                    // OGW
    digitalWrite(rot, LOW);
    digitalWrite(gelb, LOW);
    digitalWrite(gruen, HIGH);            // LED grün leuchtet wenn Abstand über 35cm
  }
}


http://blog.weezerle.de/2012/01/10/arduino-mit-abstandssensor-srf05/
http://www.robot-electronics.co.uk/htm/srf05tech.htm
http://www.robot-electronics.co.uk/htm/sonar_faq.htm






*********************************************************
9. BUCH: Einfacher Einstieg in die Elektronik mit AVR-Mikrocontroller und BASCOM
S.421  Entfernungsmesser mit SRF02 über I2C  (Distanzmesser für die Auto-Garage)

Arduino SRF02 Ultrasonic range finder

Ultraschallsensor (SRF02)


Ultraschall Entfernungsmesser mit I2C Interface
Funtionsweise ähnlich wie SRF02, SRF05 und SRF10 von  Devantech.

Reichweite in der ein Dm 55mm Plastikrohr erkannt wurde.

Ultraschall Entfernungssensor

Devantech

Der SRF02 ist der der kostengünstigste Ultraschallsensor, der sowohl über eine I2C- und eine serielle Schnittstelle verfügt. Neue Algorithmen der Devantech AutoTune-Technologie verringern die minimale Reichweite bei bestmöglicher Leistungsfähigkeit - keine manuelle Kalibrierung erforderlich. Zusätzlich erlauben es neue Befehle, den Sensor gesondert als Sender bzw. Empfänger zu betreiben. Das heißt, der SRF02 kann einen Ultraschallimpuls abgeben, ohne den normalerweise darauffolgenden Empfangszyklus zu durchlaufen, oder aber er kann einen Empfangszyklus durchlaufen ohne vorher einen Impuls zu senden.

SRF02
Messbereich 16 cm ... 6 m
Versorgungsspannung 5V DC
Stromaufnahme (typ.) 4 mA
Abmessungen B x T x H 24 x 20 x 17 mm
Gewicht 4,6 g
Einheiten µs/mm/inch
Frequenz 40 kHz
Schnittstellen I2C, seriell

Betriebsarten
Der SRF02 kann auf 2 Arten betrieben werden, im I2C-Modus oder im seriellen Modus.
Die Betriebsart kann mit dem Mode-Pin angegeben werden.
Für den seriellen Modus wird es an Masse angeschlossen, für den I2C-Modus wird es nicht verbunden.

http://www.hobbytronics.co.uk/srf02-ultrasonic-rangefinder
https://github.com/LeoColomb/Arduino-SRF/tree/master/examples/SRF02
https://www.robotics.org.za/index.php?route=product/product&product_id=281

http://www.grappendorf.net/arduino-atmel-avr/arduino-libraries/srf02-ultrasonic-distance-sensor





SRF02 Ultrasonic sensor (SKU:SEN0005)

http://www.dfrobot.com/wiki/index.php/SRF02_Ultrasonic_sensor_%28SKU:SEN0005%29


Entfernungsmesser mit SRF02



Der Mode-pin bleibt im I2C-Mode offen (unbeschaltet).
(Pin-Mode mit  Pin-GND ist nur bei  RS232-Modus verbunden)
Von SDA bzw. SCL Pullup-Widerstände (ca. 1,8k bis 10k) gegen +5V.
Standard-Slave-Adresse ist hexadezimal &hE0 = dezimal 224
Bis zu 16 Abstandssensoren lassen sich an einem I2C-Port adressieren.
Entfernungsmessung: 15cm bis 6 Meter
In Register 0 steht die Firmware-Version.
Wird eine 81 in das Register 0 geschrieben so wird der Abstand in cm ausgegeben.

In Register 2 und 3 steht die Entfernung aufgeteilt in 2 Byte.

Anwendungsbeispiele:
Abstandsmesser in Garage
Roboter-Anti-Kollision


BASCOM-Programm

' Abstandsmessung mit SRFO2 ueber I2C (C.5 und 0.4)
' In: SRFO2 ueber I2C (C.4 und C.5)
' Out: Portd2 bis Portd7: LCD
' Out: Alarm_LED an PortB.1 leuchtet auf wenn Abstand > 25 cm

$regfile = "m8def.dat"
$crystal = 1000000

Config Lcdpin = Pin , Db4 = Portd.4 , Db5 = Portd.5 , Db6 = Portd.6    Db7 = Portd.7 ,
E - Portd.3    Rs = Portd.2
Config Lcd = 16 * 2
Config Portd = Output

Config Portb - Output
Alarm_led Alias Portb.1

Config Sda = Portc.4
Config Scl = Portc.5
Const Srf02_adresse = 224                '&HEO I2C Adresse des Abstandssensors
Const Srf02_1ese_adresse = 225    '&HEl 12C Adresse des Abstandssensors

Dim Firmware As Byte

Dim High_byte As Byte
Dim Low_byte As Byte
Dim Entfernung As Integer

-Begruessung:---
Cls
Cursor Off
Lcd "Abstandssensor"
Wait 2

I2cinit

'---Firmware lesen:
I2csend Srf02_adresse , 0    'gleichbedeutend mit
folgenden Befehlen:
' I2cstart
' I2cwbyte Srf02adresse    'Leseregister festlegen
' I2cwbyte 0
' I2cstop

I2creceive Srf02_lese_adresse , Firmware    'gleichbedeutend mit folgenden Befehlen
' I2cstart
' I2cwbyte Srf02_lese_adresse    'Leseregister festlegen
' I2crbyte Firmware , Nack
' I2cstop
'________

Lowerline
Lcd  "Firmware"
Lcd Firmware
Wait 1
Cls

'Abstandsmessung:
Do

'---Messung in Zentimetern starten:
I2cstart
I2cwbyte Srf02_adresse    'Device
I2cwbyte 0    'Befehl schreiben
I2cwbyte 81    'Einheit ist Zentimeter
I2cstop
'____

'---Warten bis Messung zu Ende:
Warteaufmessung:
Waitms 1
'Firmware lesen:
I2csend Srf02_adresse , 0    'gleichbedeutend mit folgenden Befehlen:
' I2cstart
' I2cwbyte Srf02_adresse    'Leseregister festlegen
' I2cwbyte 0
' I2cstop

I2creceive Srf02_lese_adresse , Firmware    'gleichbedeutend mit folgenden Befehlen
' I2cstart
' I2cwbyte Srf02_1ese_adresse    'Leseregister festlegen
' I2crbyte Firmware , Nack
' I2cstop
If Firmware - 255 Then Goto Warteaufmessung
'---

'---Entfernung auslesen:
I2csend Srf02_adresse , 2    'gleichbedeutend mit folgenden Befehlen:
' I2cstart
' I2cwbyte Srf02_adresse      'Device
' I2cwbyte 2    'Leseregister festlegen
(High Byte)
I2cstop



I2cstart
I2cwbyte Srf02_lese_adresse    'Deviceread
I2crbyte High_byte , Ack    'MSB holen
I2crbyte Low_byte , Nack    'LSB holen
I2cstop

'--nur Kontrolle:
Upperline
Lcd "high:"
Lcd High_byte
Lcd " low:"
Lcd Low_byte
Lcd "    "
'---

'Hight_Byte und Low_Byte zum Entfernungswert zusamenfassen:
Entfernung = High_byte * 256
Entfernung = Entfernung + Low_byte

Lowerline
Lcd "Entfernung: "
Lcd Entfernung
Lcd "    "

If Entfernung < 25 Then
Alarm_led = 1
Else
Alarm_led = 0
End If

Waitms 500
Loop
End





SRF02 Ultraschall-Abstandssensor


Die SRF02 ein Ultraschallabstandssensor mit einem I2C-Bibliothek. Diese Bibliothek vereinfacht den Zugriff auf SRF02 Module aus Arduino Code. Eine Besonderheit der SRF02 ist, dass Sie zunächst eine neue Messung und nach ca. auslösen. 65 ms können Sie das Ergebnis ablesen. Das SRF02 Bibliothek können Sie so viele Sensorinstanzen Sie angeschlossen haben deklarieren und mit einem einzigen Aufruf SRF02 :: update () alle Instanzen ausgelöst, um eine neue Messung durchzuführen. Sie brauchen nicht, über Timing-Probleme zu kümmern. Rufen SRF02 :: update () regelmäßig von innerhalb der Schleife) Funktion (. Wenn neue Messergebnisse verfügbar sind, werden von den I2C-Bus abgeholt und in die Instanz-Variablen gespeichert werden. Der aktuelle Entfernungswert ist durch die read () -Methode zugänglich.

Download und Installation
Laden Sie das ZIP-Archiv herunter und entpacken Sie SRF02-1_4.zip
SRF02-1_4.zip in Ihre <Pfad zu Arduino> / Bibliotheken-Verzeichnis.
Starten Arduino und wählen Sie Datei-> Sketchbook-> Examples-> Bibliothek SRF02-> SRF02 aus dem Menü, um das Beispiel Skizze zu laden.

Schaltung
Das SRF02 Modul sollte auf dem I2C-Bus des Arduino verbunden werden, dh die analogen Port-Pins 4 (SDA) und 5 (SCL). Keine Pull-up-Widerstände sind notwendig, da der Atmel MCU enthält sie bereits intern.

Funktionen
SRF02 (uint8_t deviceId, uint8_t-Modus)
Erstellen Sie eine neue Instanz einer SRF02 Sensor mit dem angegebenen (7-bit) Geräte-ID und Messmodus (SRF02_INCHES, SRF02_CENTIMETERS, SRF02_MICROSECONDS).

unsigned int read()
Lesen Sie den aktuellen Abstandswert.

update()
Rufen Sie diese Methode von der in der Schleife () Funktion. Die meiste Zeit update () gibt einfach und tut nichts. Wenn das Messintervall abgelaufen ist, ist der letzte Messwert geholt und eine neue Messung ausgelöst.

setInterval(unsigned int interval)
Stellen Sie das Messintervall in Millisekunden. Der Standardwert ist 70 ms.

configureDeviceId(uint8_t currentDeviceId, uint8_t newDeviceId)
Neue Geräte werden immer so konfiguriert, dass die Geräte-ID 0x70 verwenden. Rufen Sie diese Methode, um die Geräte-ID zu ändern. Diese Einzel SRF02 Sensor an die I2C-Bus nur vor dem Aufruf dieser Methode zu verbinden!

Beispiel
Angenommen, Sie haben drei SRF02 mit Gerätekennungen 0x70, 0x71 und 0x72 auf dem I2C-Bus verbunden sind. Der folgende Code liest regelmäßig die Sensoren und schreibt die Abstandsmessungen jede Sekunde auf die serielle Schnittstelle.


#include "Wire.h"
#include "SRF02.h"

SRF02 srf02[3] = {
  SRF02(0x70, SRF02_CENTIMETERS),
  SRF02(0x71, SRF02_CENTIMETERS),
  SRF02(0x72, SRF02_CENTIMETERS)
};

unsigned long nextPrint = 0;

void setup() {
  Serial.begin(9600);
  Wire.begin();
  SRF02::setInterval(500);
}

void loop() {
  while (true) {
    SRF02::update();
    if (millis() > nextPrint) {
      Serial.print(srf02[0].read());
      Serial.print(",");
      Serial.print(srf02[1].read());
      Serial.print(",");
      Serial.print(srf02[2].read());
      Serial.println();
      nextPrint = millis () + 1000;
    }
  }
}



Processing SRF02.pde

/*
 * SRF02 library example code
 *
 * Reads values from a single SRF02 sensor and writes to the serial
 * interface at 9600 baud.
 *
 * The contents of this file are subject to the Apache License Version
 * 2.0 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is grappendorf.net Arduino Libraries / SRF02.
 *
 * The Initial Developer of the Original Code is
 * Dirk Grappendorf (www.grappendorf.net)
 * Portions created by the Initial Developer are Copyright (C) 2008-2011
 * the Initial Developer. All Rights Reserved.
 */

#include "Wire.h"
#include "SRF02.h"

SRF02 sensor(0x70, SRF02_CENTIMETERS);

unsigned long nextPrint = 0;

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

void loop()
{
  SRF02::update();
  if (millis() > nextPrint)
  {
    Serial.println(sensor.read());
    nextPrint = millis () + 1000;
  }
}


Ändern des I2C-ID von mehreren SRF02s
Da alle SRF02 sind mit der gleichen ID (0x70) ausgeliefert, die Änderung ihrer Ide ist ein bisschen langweilig, denn man kann nur ein Gerät zur selben Zeit ändern. Zuerst müssen Sie ein Programm, das nichts anderes tut, als Initialisierung der I2C-Schnittstelle (Wire.begin ()) und dem Aufruf des SRF02 :: configure Geräte-ID (0x70, NEWID () -Methode zu ersetzen NEWID durch die id Sie das SRF02 hören möchten) müssen . Übertragen Sie das Programm, schließen genau ein SRF02 und starten Sie die Arduino. Das SRF02 ist nun programmiert. Am besten ist es, ein Etikett auf den Sensor, die Sie die neue ID erzählt bleiben, da dies SRF02 wird nie mehr zu hören ID 0x70 (außer Sie es wieder auf den Standard-ID zu ändern). Schalten Sie, ändern Sie den Code für den nächsten Sensor (ersetzen NEWID mit einem anderen noch nicht zugeordneten ID), übertragen Sie das Programm, schließen Sie den nächsten Sensor und schalten Sie den Arduino. Wiederholen Sie, bis Sie alle Ihre SRF02s programmiert haben.

Die folgende Skizze stellt eine neue Sensor mit der Geräte-ID 0x70 auf dem neuen ID 0x71:


#include "Wire.h"
#include "SRF02.h"

void setup() {
  Wire.begin();
  SRF02::configureDeviceId(0x70, 0x71);
}

void loop() {
}



Lizenz

Das SRF02 Arduino Bibliothek wird unter der GNU Lesser General Public License Version 3.0 lizenziert.
http://www.gnu.org/licenses/lgpl.html

http://www.grappendorf.net/arduino-atmel-avr/arduino-libraries/srf02-ultrasonic-distance-sensor

http://www.robot-electronics.co.uk/htm/arduino_examples.htm
https://github.com/grappendorf/arduino-framework/tree/master/SRF02


Diy Arduino Radar

http://www.instructables.com/id/Introduction-14/


SRFxx Sonic Range Finder Reader

http://www.arduino.cc/en/Tutorial/SFRRangerReader
http://www.shop.robotikhardware.de/shop/catalog/product_info.php?products_id=168
http://de.manu-systems.com/SRF02.shtml
http://rn-wissen.de/wiki/index.php/Ultraschallsensor_SRF02_am_RN-Board
http://www.cc-zwei.de/wiki/index.php?title=Ultraschallsensoren
http://www.daedalus.ei.tum.de/index.php/de/archiv/material/sensoren/ultraschallsensor-srf02
http://www.robot-electronics.co.uk/htm/srf02tech.htm
http://www.robot-electronics.co.uk/htm/srf02techI2C.htm




(Mode-pin mit  GND-pin verbunden bei RS232-Modus)





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

SRF02_Ver_1_0

Software:

Die von mir geschriebene Software (SRF02_Ver_1_0) zur Steuerung des Treppenlichts ist so programmiert, dass die Schwellwerte schnell und einfach ermittelt werden können.

Hierzu werden alle nötigen Daten per serieller Schnittstelle ausgegeben.

http://jleopold.de/2010/08/05/arduino-treppenlicht/


/*
 * Treppenlicht mit 2x SRF02
 *                  1x LDR
 *                  45 LEDs in fünf Gruppen
 */

//***LIBRARIES***
#include "Wire.h"
#include "SRF02.h"

//***AUFRUFE***
SRF02 Sensor[2] =
{
  SRF02(0x70, SRF02_CENTIMETERS),
  SRF02(0x71, SRF02_CENTIMETERS)
};

usw.




SRF02 sensor reader
Devantech SRF02 ultrasonic sensor.
  1. SDA - Analog pin 4
  2.  
  3. SCL - Analog pin 5
http://www.ipaste.org/ivg




*********************************************************
ARDUINO-IDE v1.0.1   
http://www.arduino.cc/
http://www.arduino.cc/en/Main/ArduinoBoardDiecimila


Processing-IDE 
https://processing.org/






*********************************************************
Lernset-3   Funduino UNO R3  € 50,-

Alle Lernset-3 Sketches mit genauer Beschreibung von mir siehe
715_d_ARDUINO-x_Funduino UNO R3 - Lernset 3  +++ ANLEITUNG (68 Seiten)_3d.doc



3.10a Sketch Nr.10: Entfernung messen  mit US-Modul HC-SR04

Aufgabe: Mit den Ultraschallsensor HC-SR04 soll eine Entfernung gemessen und mit dem „serial-monitor“ angezeigt werden.

Material: Arduino / Breadboard / US-Sensor HC-SR04 / Kabel 0,65mm AWR-22

Lerninhalt: Wie funktioniert der Ultraschallsensor?

Der Sensor hat vier Anschlüsse.

a) 5V(+)

b) GND (–)

c) Echo

d) Trigger

Die Anschlüsse 5V und GND verstehen sich von selbst, sie versorgen den Sensor mit Energie.

Der Pin "Trigger" bekommt vom Mikrocontroller-Board ein kurzes Signal (5V), wodurch eine Schallwelle vom Ultraschallsensor ausgelöst wird.

Sobald die Schallwelle gegen eine Wand oder sonstigen Gegenstand stößt, wird sie reflektiert und kommt irgendwann auch wieder zum Ultraschallsensor zurück.

Sobald der Sensor diese zurückgekehrte Schallwelle erkennt, sendet der Sensor auf dem "Echo" Pin ein 5V Signal an das Mikrocontroller-Board.

Dieser misst dann lediglich die Zeit zwischen dem Aussenden und der Rückkehr der Schallwelle und rechnet diese Zeit dann in eine Entfernung um.


ORIGINAL

Sketch Nr.10 Entfernung messen  mit US-Modul HC-SR04_1a.ino

// Titel: Sketch Nr.10 Entfernung messen  mit US-Modul HC-SR04
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Sketch Nr.10 Entfernung messen  mit US-Modul HC-SR04_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


// 3.10a Sketch Nr.10 Entfernung messen
/* Info: Anstelle von "int" steht bei 2 Variablen "long". Das hat den 
 Vorteil: dass eine größere Zahl gespeichert werden kann. Das hat den
 Nachteil: Die Variable benötigt mehr Platz im Speicher.
 */

int trigger=7;     // Das Wort trigger ist jetzt pin-7
int echo=6;        // Das Wort echo ist jetzt die pin-6.
// Info: Anstelle von "int" steht hier vor den beiden Variablen "long". Das hat den Vorteil, dass eine größere Zahl gespeichert werden kann. Nachteil: Die Variable benötigt mehr Platz im Speicher.
long dauer=0;      // Das Wort dauer ist jetzt eine Variable, unter der die Zeit gespeichert wird, die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0.
long entfernung=0; // Das Wort entfernung ist jetzt die variable, unter der die berechnete Entfernung gespeichert wird.

void setup(){      // Serielle kommunikation starten, damit man sich später die Werte am Serial-Monitor ansehen kann.
  Serial.begin (9600);
  pinMode(trigger, OUTPUT); // "trigger" (pin-7) ist ein Ausgang.
  pinMode(echo, INPUT);     // "echo"    (pin-6) ist ein Eingang.
}

void loop(){    // Endlosschleifen Prg.-Teil
  digitalWrite(trigger, LOW); // Hier nimmt man die Spannung für kurze Zeit vom Trigger-Pin, damit man später beim senden des Trigger-Signals ein rauschfreies Signal hat.
  delay(5);      // Dauer: 5 Millisekunden
  digitalWrite(trigger, HIGH);  // sendet eine Ultraschallwelle los
  delay(10);                    // Dieser 40kHz Ton erklingt für 10 Millisekunden.
  digitalWrite(trigger, LOW);   // es wird der 40kHz Ton  abgeschaltet.
  dauer = pulseIn(echo, HIGH);  // mit dem Befehl "pulseIn" zählt der Mikrokontroller die Zeit in Millisekunden, bis der Schall zum Ultraschallsensor zurückkehrt.
  entfernung = (dauer/2) / 29.1;

  /* 
   Nun berechnet man die Entfernung in Zentimetern. 
   Man teilt zunächst die Zeit durch zwei (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück). 
   Den Wert teilt man noch durch 29.1 und erhält dann den Wert in Zentimetern, 
   da der Schall in der Luft eine Geschwindigkeit von einem Zentimeter pro 29,1 Mikrosekunden hat.  
   Beispiel: 
   Der Sensor misst eine Zeit von 2000 Mikrosekunden. 
   Das sind dann 1000 Mikrosekunden pro Strecke. 
   Nun teilt man 1000 durch 29.1 (Weil der Schall ja 1cm pro 29,1 Mikrosekunden zurücklegt) und erhält den Wert 34,3cm   
   */

  if (entfernung >= 500 || entfernung <= 0) { // Wenn die gemessene Entfernung über 500cm oder unter 0cm liegt
    Serial.println("Kein Messwert"); // dann soll der Serial-Monitor ausgeben "Kein Messwert", weil Messwerte in diesen Bereichen falsch oder ungenau sind.
  }
  else {                             //  Ansonsten...
    Serial.print(entfernung);        // ...soll der Wert der Entfernung an den serial monitor hier ausgegeben werden.
    Serial.println(" cm");
  }
  delay(1000);                        // Eine Pause 1 Sekunde sorgt in ca. jeder Sekunde für einen neuen Messwert gemessen wird
}




Erweiterung des Programms:

Wenn ein Abstand unter 80cm gemessen wird, soll ein Piezo-Lautsprecher piepsen.


Sketch Nr.10 Entfernung messen  mit US-Modul HC-SR04 & Piezo-Ls_1a.ino

// Titel: Sketch Nr.10 Entfernung messen  mit US-Modul HC-SR04 & Piezo-Ls
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Sketch Nr.10 Entfernung messen  mit US-Modul HC-SR04 & Piezo-Ls_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


// 3.10a Sketch Nr.10 Entfernung messen
/* Info: Anstelle von "int" steht bei 2 Variablen "long". Das hat den 
 Vorteil: dass eine größere Zahl gespeichert werden kann. Das hat den
 Nachteil: Die Variable benötigt mehr Platz im Speicher.
 */

int trigger=12;     // Trigger ist pin-12
int echo=13;        // Echo ist pin-13
// Info: Anstelle von "int" steht hier vor den beiden Variablen "long". Das hat den Vorteil, dass eine größere Zahl gespeichert werden kann. Nachteil: Die Variable benötigt mehr Platz im Speicher.
long dauer=0;       // Das Wort dauer ist jetzt eine Variable, unter der die Zeit gespeichert wird, die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0.
long entfernung=0;  // Das Wort entfernung ist jetzt die Variable, unter der die berechnete Entfernung gespeichert wird.
int piezo=5;        // Piezo-Ls an pin-5 anschließen

void setup(){       // Serielle kommunikation starten, damit man sich später die Werte am Serial-Monitor ansehen kann
  Serial.begin (9600);
  pinMode(trigger, OUTPUT);  // "trigger" (pin-7) ist ein Ausgang
  pinMode(echo, INPUT);      // "echo"    (pin-6) ist ein Eingang
  pinMode(piezo, OUTPUT);    // Der Piezo-Lautsprecher an pin-5 soll ein Ausgang sein. Logisch, weil der ja vom Mikrokontroller-Board ja eine Spannung benötigt um zu piepsen
}

void loop(){    // Endlosschleifen Prg.-Teil
  digitalWrite(trigger, LOW); // Hier nimmt man die Spannung für kurze Zeit vom Trigger-Pin, damit man später beim senden des Trigger-Signals ein rauschfreies Signal hat.
  delay(5);      // Dauer: 5 Millisekunden
  digitalWrite(trigger, HIGH);   // sendet eine Ultraschallwelle los
  delay(10);                     // Dieser 40kHz Ton erklingt für 10 Millisekunden.
  digitalWrite(trigger, LOW);    // es wird der 40kHz Ton  abgeschaltet.
  dauer = pulseIn(echo, HIGH);   // mit dem Befehl "pulseIn" zählt der Mikrokontroller die Zeit in Millisekunden, bis der Schall zum Ultraschallsensor zurückkehrt.
  entfernung = (dauer/2) / 29.1; // durch 2 wegen hin und rück und Schallgeschwindigkeit 29,1us/cm

  /* 
   Nun berechnet man die Entfernung in Zentimetern. 
   Man teilt zunächst die Zeit durch zwei (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück). 
   Den Wert teilt man noch durch 29.1 und erhält dann den Wert in Zentimetern, 
   da der Schall in der Luft eine Geschwindigkeit von einem Zentimeter pro 29,1 Mikrosekunden hat.  
   Beispiel: 
   Der Sensor misst eine Zeit von 2000 Mikrosekunden. 
   Das sind dann 1000 Mikrosekunden pro Strecke. 
   Nun teilt man 1000 durch 29.1 (Weil der Schall ja 1cm pro 29,1 Mikrosekunden zurücklegt) und erhält den Wert 34,3cm   
   */

  if (entfernung >= 500 || entfernung <= 0) { // Wenn die gemessene Entfernung über 500cm oder unter 0cm liegt
    Serial.println("Kein Messwert"); // dann soll der Serial-Monitor ausgeben "Kein Messwert", weil Messwerte in diesen Bereichen falsch oder ungenau sind.
  }
  else {                             //  Ansonsten...
    Serial.print(entfernung);        // ...soll der Wert der Entfernung an den serial monitor hier ausgegeben werden.
    Serial.println(" cm");
  }


  if (entfernung <= 80){             // Dauer-Alarm wenn Abstand kleiner 80cm
    digitalWrite(piezo,HIGH);
  }
  else{
    digitalWrite(piezo,LOW);
  }


  delay(1000);                        // Eine Pause 1 Sekunde sorgt in ca. jeder Sekunde für einen neuen Messwert gemessen wird
}



// 3.10.1 Rückfahrwarner für Kfz mit Blink-Led unter 40cm

Mit diesem Code lässt sich ein Rückfahrwarner konstruieren.

Am Pin12 wird zusätzlich zu dem bereits angeschlossenen Ultraschallsensor aus dem Sketch 10 ("Entfernung messen" eine LED angeschlossen.

http://funduino.de/index.php/3-programmieren/nr-10-entfernung

 

Sketch Nr.10.1 Rückfahrwarner für Kfz US-Modul HC-SR04 & LED_1a.ino



// Titel: Sketch Nr.10.1 Rückfahrwarner für Kfz
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Sketch Nr.10.1 Rückfahrwarner für Kfz US-Modul HC-SR04 & LED_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


// 3.10a Sketch Nr.10.1 Rückfahrwarner für Kfz
/* Info: Anstelle von "int" steht bei 2 Variablen "long". Das hat den 
 Vorteil: dass eine größere Zahl gespeichert werden kann. Das hat den
 Nachteil: Die Variable benötigt mehr Platz im Speicher.
 */

int trigger=7;      // Trigger ist pin-7
int echo=6;         // Echo ist pin-6
int LED=12;         // LED ist pin-6
// Info: Anstelle von "int" steht hier vor den beiden Variablen "long". Das hat den Vorteil, dass eine größere Zahl gespeichert werden kann. Nachteil: Die Variable benötigt mehr Platz im Speicher.
long dauer=0;       // Das Wort dauer ist jetzt eine Variable, unter der die Zeit gespeichert wird, die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0.
long entfernung=0;  // Das Wort entfernung ist jetzt die variable, unter der die berechnete Entfernung gespeichert wird.
int piezo=5;        // Piezo-Ls an pin-5 anschließen

void setup(){       // Serielle kommunikation starten, damit man sich später die Werte am Serial-Monitor ansehen kann
  Serial.begin (9600);
  pinMode(trigger, OUTPUT);  // "trigger" (pin-7) ist ein Ausgang
  pinMode(echo, INPUT);      // "echo"    (pin-6) ist ein Eingang
  pinMode(12, OUTPUT);       // LED an pin-12 soll ein Ausgang sein. Logisch, weil der ja vom Mikrokontroller-Board ja eine Spannung benötigt um zu leuchten
}

void loop(){                     // Endlosschleifen Prg.-Teil
  digitalWrite(trigger, LOW);    // Hier nimmt man die Spannung für kurze Zeit vom Trigger-Pin, damit man später beim senden des Trigger-Signals ein rauschfreies Signal hat.
  delay(5);                      // Dauer: 5 Millisekunden
  digitalWrite(trigger, HIGH);   // sendet eine Ultraschallwelle los
  delay(10);                     // Dieser 40kHz Ton erklingt für 10 Millisekunden.
  digitalWrite(trigger, LOW);    // es wird der 40kHz Ton  abgeschaltet.
  dauer = pulseIn(echo, HIGH);   // mit dem Befehl "pulseIn" zählt der Mikrokontroller die Zeit in Millisekunden, bis der Schall zum Ultraschallsensor zurückkehrt.
  entfernung = (dauer/2) / 29.1; // durch 2 wegen hin und rück und Schallgeschwindigkeit 29,1us/cm




  /* 
   Nun berechnet man die Entfernung in Zentimetern. 
   Man teilt zunächst die Zeit durch zwei (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück). 
   Den Wert teilt man noch durch 29.1 und erhält dann den Wert in Zentimetern, 
   da der Schall in der Luft eine Geschwindigkeit von einem Zentimeter pro 29,1 Mikrosekunden hat.  
   Beispiel: 
   Der Sensor misst eine Zeit von 2000 Mikrosekunden. 
   Das sind dann 1000 Mikrosekunden pro Strecke. 
   Nun teilt man 1000 durch 29.1 (Weil der Schall ja 1cm pro 29,1 Mikrosekunden zurücklegt) und erhält den Wert 34,3cm   
   */

  if (entfernung >= 500 || entfernung <= 0) { // Wenn die gemessene Entfernung über 500cm oder unter 0cm liegt
    Serial.println("Kein Messwert");          // dann soll der Serial-Monitor ausgeben "Kein Messwert", weil Messwerte in diesen Bereichen falsch oder ungenau sind.
  }
  else {                                      //  Ansonsten...
    Serial.print(entfernung);                 // ...soll der Wert der Entfernung an den Serial-Monitor gesendet werden.
    Serial.println(" cm");
  }


  if (entfernung <= 40){                      // Blink-Alarm wenn Abstand kleiner 40cm
    digitalWrite(LED,HIGH);
    delay(entfernung*3);                      // bei kleiner werdenden Abstand wird Blinkfrequenz schneller
    digitalWrite(LED, LOW);
    delay(entfernung*3);
  }
}

http://funduino.de/index.php/3-programmieren/nr-10-entfernung/rueckfahrwarner






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

Arduino - Eine Einführung

Lichtschranke mittels Reflexoptokoppler CNY70 (kurze Distanz)

Der Reflexoptokoppler CNY70 ist mit einer Infrarot-Sendediode (Wellenlänge 950 nm)
 d.h. dein Auge sieht das Licht nicht, wohl aber deine Handykamera und einem Fototransistor als Empfänger ausgestattet.
Dieses Bauteil kann man für viele verschiedene Dinge verwenden, z.B. als berührungsloser Sensor, ob eine Tür offen ist:
Die Infrarotdiode sendet ein Licht aus und der Fototransistor detektiert, ob dieses reflektiert wurde.
Man kann auch zwei von diesen Teilen verwenden, um einen Roboter eine Linie nachfahren zu lassen: siehe Liniensensor.
Hier wollen wir den CNY70 zweckentfremden und zwei Stück davon als Lichtschranke für kurze Distanzen (10 cm sind möglich) verwenden.
Vorweg Achtung:
Je nach Hersteller sind die Anschlüsse Anode Cathode  UND  Emitter Collektor  verschieden: Vishay CNY70 bzw. Temic CNY70.

http://popovic.info/html/arduino/datasheets/vishay_cny70.pdf
http://popovic.info/html/arduino/datasheets/temic_cny70.pdf


Lichtschranke mittels TEMIC K153P (kurze Distanz)

Diese Lichtschranke besteht aus einer Infrarot-Sendediode (hellblau; Wellenlänge: 950 nm) und einem Fototransistor als Empfänger (schwarz). Der große Vorteil dieses Pärchens ist der Preis: bei Pollin kosten 10 Paare weniger als 1 €! Die Inbetriebnahme der Temic K153P ist einfach:


Funktionsweise:

Die Infrarotdiode sendet ein Licht, das für unser Auge nicht sichtbar ist, aus. Solange kein Licht auf die Basis des Fototransistors trifft, sperrt dieser, d.h. am Port des µC liegt HIGH an.
Sobald jedoch Licht auf die Basis des Fototransistors trifft öffnet sich die C-E-Strecke und am Port liegt LOW an.

Nachteile: Der Fototranistor ist empfindlich für Streulicht. Somit sind nur sehr begrenzte Reichweiten möglich.

Aufgabe:

  1. Experimentiere mit verschiedenen Vorwiderständen (Poti verwenden) für den Fototransistor, um zu testen, welche Reichweite möglich ist.

Gabellichtschranke TCST2000 (CNY37)

Funktionsweise:
Die Infrarotdiode sendet ein Licht, das für unser Auge nicht sichtbar ist, aus.
Mit dem Fotoapparat kannst du diese Licht jedoch sichtbar machen, siehe Abbildung oben.
Solange kein Licht auf die Basis des Fototransistors trifft, sperrt dieser, d.h. am Port des µC liegt LOW an.
Sobald jedoch Licht auf die Basis des Fototransistors trifft öffnet sich die C-E-Strecke und am Port liegt HIGH an.


Schaltbild:
Achtung: Im Datenblatt des TCST2000 wird ein Pulldown-Widerstand von 100 Ohm am Transistor empfohlen.
In der Praxis musste ich jedoch zwischen 500 Ohm und 10 kOhm verwenden.
http://popovic.info/html/arduino/datasheets/TCST-2000.pdf

Code:

int lichtSchranke = 2;

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

void loop() {
  Serial.println(digitalRead(lichtSchranke));
  delay(1);
}


Abstandssensor SHARP GP2Y0A02YK0F (mittlere Distanz)

Der Sharp GP2Y0A02YK0F ist z.B. bei Segor günstig erhältlich und deckt eine Reichweite von 20 cm - 150 cm ab. Alternativ gibt es noch einen deutlich teureren Sensor (Sharp GP2 Y0A710 K0F), der bis zu 550 cm Entfernungen misst.

Tipp: In jedem Fall die passenden JST-3-Pin-Stecker bzw. Verbindungskabel mitbestellen.

Der große Vorteil gegenüber den oben verwendeten Lichtschranken ist, dass bei diesem Modell das gesendete Infrarotlicht moduliert wird, d.h. es ist nicht störanfällig für Streustrahlung. Verwendet werden solche Sensoren z.B. bei Urinalen, in der Robotik, ...

Der Ausgang des Sensors liefert ein Potenzial zwischen 0 V und 5 V und wird an einen analogen Port angeschlossen. Am analogen Port haben wir eine 10 bit Auflösung, d.h. (210=1024 verschiedene) Messwerte von 0 bis 1023 sind möglich. Nun muss man den Messwert noch in die Entfernung zurückrechnen. Dazu muss kann man die Kurve im Datenblatt durch eine Hyperbel annähern (noch besser wäre evtl. eine Exponentialfunktion). Bei mir klappt es ganz gut mit folgender Formel:


const int irPin = 1;     // analoger Eingang für den Abstandssensor
float distance = 0;      // Objektentfernung
void setup() {
  Serial.begin(9600); // serielle Schnittstelle bereitstellen
}

void loop() { 
    distance = 10650 * pow(analogRead(irPin),-0.935)-15;   // Achtung: Sensor eichen!
   Serial.println(distance);
   delay(500);
}

Wichtig: die Zahlen 10650 und -15 sollten dem Sensor angepasst werden, d.h. man stellt ein Hinderniss in 50 cm und 100 cm Entfernung und ändert die Zahl so lange, bis man eine bestmögliche Übereinstimmung hat. Klar sollte sein, dass der Sensor nur in den vorgesehenen Distanzen ein gutes Messergebnis liefert. Möchte man dennoch kleinere Entfernungen damit messen, so müsste man die Abstandsformel ändern oder besser einen für diesen Messbereich ausgelegten Sensor verwenden.


Bemerkung:

Abgebildet ist ein halbes "screw-shield". Diese Dinger sind sehr praktisch, da man Sensorkabel anschrauben und außerdem weitere Shields aufstecken kann.


Ultraschall-Entfernungsmesser  Parallax PING)))   von 2 cm bis 3m

Eigentlich gibt es günstigere Ultraschall-Entfernungsmesser als den PING))) von Parallax (Datenblatt). Da wir dieses Bauteil jedoch ohnehin vorrätig haben hier ein Beispiel:
Die Entfernung zu einem Gegenstand (Segel auf Modellauto) wird gemessen. Wenn diese kleiner als 50 cm wird, soll  eine LED leuchten und ein Elektromagnet eine Kugel fallen lassen. Der Elektromagnet wird via Transistor (BD437) angeschlossen, da er eine hohe Stromstärke benötigt.

Warnung: Wird der PING-Sensor versehentlich mit 9 V verbunden geht er kaputt. Zu erkennen ist dies am verschmorten Aufkleber auf dem IC (Foto folgt).

Sketch:

// Ursprünglich Idee von David A. Mellis und Tom Igoe 
// siehe http://www.arduino.cc/en/Tutorial/Ping

#define magnetPin 2
#define pingPin 7
#define ledPin 13
long duration, cm;

void setup() {
  Serial.begin(9600);
  pinMode(ledPin, OUTPUT);
  pinMode(magnetPin, OUTPUT);
}

void loop(){   // der Port pingPin wird als Ausgang geschaltet und ein 5 ms HIGH-Impuls ausgegeben.
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);
  // nun wird der pingPin Port als Eingang geschaltet und gemessen, wie lange es dauert, bis das Eche eintrifft.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);
   // Zeit in Entfernung umrechnen:
  cm = duration / 29 / 2;  // Schallgeschwindigkeit 29 cm/s; halbe Strecke
  Serial.print(cm);
  Serial.println("cm");
  if(cm < 50){
    digitalWrite(ledPin, HIGH);
    digitalWrite(magnetPin, LOW);
  }
  else{
    digitalWrite(ledPin, LOW);
    digitalWrite(magnetPin , HIGH);
  }
  delay(100);
}


Making Things Talk (by Tom Igoe):

Ultraschall-Entfernungsmesser Parallax PING)))
https://www.parallax.com/


Datenblatt:
http://popovic.info/html/arduino/datasheets/parallax_ping.pdf
http://popovic.info/html/arduino/datasheets/st_bd437.pdf


505_d_Sensor-x_Arduino - Learning - TUTORIAL (711 Seiten)_1a.pdf



Ultraschall-Entfernungsmesser (HC-SR04: 2 cm bis 4 m)

Deutlich günstiger als der PING-Sensor von Parallax ist der HC-SR04 von Cytron Technologies. Er benötigt ein 10 µs langes Triggersignal, woraufhin er acht 40 kHz Impulse aussendet und misst, wie lange es bis zum Eintreffen des Echos benötigt (150 µS bis 25.000 µs). Bei fehlendem Echo werden 38.000 µs zurückgemeldet. Diese Zeit wird über den Echo-Pin ausgegeben und zwar in Form eines Impulses, dessen Weite gerade der Signallaufzeit (in µs und für hin & zurück) entspricht. Die Entfernung (in cm) berechnet sich aus der Signallaufzeit in µs durch:

s = 0.5 * t * v = 0.5 * 340 m/s * t = 0.017 * t [s in cm, t in µs]

Es gibt zwar die Ultrasonic-Bibliothek, aber der Code ist auch schnell selbst geschrieben:

Code:

# define echoPin 6
# define trigPin 7
long distance;

void setup(){
  pinMode(echoPin,INPUT);
  pinMode(trigPin,OUTPUT);
  Serial.begin(9600);
}

void loop(){
  digitalWrite(trigPin,HIGH);
  delayMicroseconds(1000);
  digitalWrite(trigPin,LOW);
  distance = pulseIn(echoPin,HIGH)*0.017;
  Serial.print(distance);
  Serial.println(" cm");
}

Sketch fritz:

// Titel: 3.10a Entfernung messen mit Ultra-Schall-Modul HC-SR04
// Beschreibung: Abstand messen 2cm bis 5m
// Autor: Fritz Prenninger
// Datum: 2014-09-26
// Sketch: _3_10a_Entfernung_messen_mit_US-Modul_HC_SR04_1b.ino
// Shield: keines
// Controller: Arduino UNO SMD
// Version: Arduino 1.0.5-r2
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// _3_10a_Entfernung_messen_mit_US-Modul_HC_SR04_1b.ino
// HC-SR04  1. Vcc auf +5V   2. Trig auf pin-7   3. Echo auf pin-6    4. GND auf GND  
// pin-5   +Buzzer-  GND

/* Anstelle von "int" steht bei 2 Variablen "long". Das hat
den Vorteil, dass eine größere Zahl gespeichert werden kann,
den Nachteil, die Variable benötigt mehr Platz im Speicher.
 */
 
int trigger=7;                         // das Wort trigger steht für pin-7
int echo=6;                            // das Wort echo steht für pin-6
long dauer=0;
/* Das Wort dauer ist eine Variable, unter der die Zeit gespeichert wird, 
die eine Schallwelle bis zur Reflektion und zurück benötigt. Startwert ist hier 0.
 */
long entfernung=0; 
// "entfernung" ist jetzt die Variable, unter der die Entfernung gespeichert wird.



void setup()                          // hier beginnt das Setup
{
  Serial.begin (9600);   
  /*die serielle Kommunikation starten, 
  damit man sich später die Werte am "Serial-Monitor" ansehen kann
  */

  pinMode(trigger, OUTPUT);           // "trigger" (pin-7) ist ein Ausgang
  pinMode(echo, INPUT);               // "echo" (pin-6) ist ein Eingang
}



void loop()                           // der Loop Teil = Hauptprogramm
{
  digitalWrite(trigger, LOW);   
  /* Hier nimmt man die Spannung für kurze Zeit vom Trigger pin-7, 
  damit man später beim Senden des Trigger-Signals ein rauschfreies Signal hat.
   */
  delay(5);                           // 5 Millisekunden Wartezeit
  digitalWrite(trigger, HIGH);        // jetzt sendet man eine Ultraschallwelle los
  delay(10);                          // dieser "Ton" erklingt für 10 Millisekunden
  digitalWrite(trigger, LOW);         // dann wird der "Ton" abgeschaltet
  dauer = pulseIn(echo, HIGH); 
  /* Mit dem Befehl "pulseIn" zählt der Mikrocontroller die Zeit in Millisekunden, 
  bis der Schall zum Ultraschallsensor zurückkehrt.
   */
// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567
  entfernung = (dauer/2) / 29.1;
  /* Nun berechnet man die Entfernung in Zentimetern. 
  Man teilt zunächst die Zeit durch zwei 
  (Weil man ja nur eine Strecke berechnen möchte und nicht die Strecke hin- und zurück). 
  Den Wert teilt man noch durch 29,1 und erhält dann den Wert in cm, da der Schall 
  in der Luft eine Geschwindigkeit von 1cm / 29,1 Mikrosekunden hat.
   Beispiel: Der Sensor misst eine Zeit von 2000 Mikrosekunden. 
   Das sind dann 1000 Mikrosekunden pro Strecke. 
   Nun teilt man 1000 durch 29.1  und erhält den Wert 34,3cm
   */
  if (entfernung >= 500 || entfernung <= 1)
    /* Wenn die gemessene Entfernung über 500cm oder unter 1cm liegt, 
     dann soll "Kein Messwert" am "Serial-Monitor" ausgeben werden,  
     weil Messwerte in diesen Bereichen falsch oder ungenau sind.
     */
  {
    Serial.println("Kein Messwert");
  }
  else   // ansonsten ..
  {
    Serial.print(entfernung);          // Entfernung an den "Serial-Monitor" 
    Serial.println(" cm");
  }
  delay(1000);                         // in ca. jeder neuen Sekunde einen neuen Messwert.
}



ARDUINO Distance Measurement - using HC-SR04
ARDUINO Entfernungsmessung - mit HC-SR04



Dies ist der Schaltplan zwischen dem Arduino UNO und ein HC-SR04 Ultraschallmodul.

Hier ist die Software, um Distanz zu messen:

ARDUINO Entfernungsmessung mit HC-SR04_1a.ino


// Titel: Sketch ARDUINO Entfernungsmessung - mit HC-SR04
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: ARDUINO Entfernungsmessung mit HC-SR04_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// ARDUINO Entfernungsmessung mit HC-SR04
/* Anschluss 
 VCC - Schließen Sie hier ein + 5V Netzteil 
 TRIG - Dies ist der Auslösestift verwendet werden, um das Modul anzuweisen, einen Impuls auszusenden. 
 - Sie tun dies durch Anlegen von + 5V, warten 10US dann die Pin low (0V) 
 ECHO - Dieser Pin wird Puls, dessen Dauer in Bezug auf Abstand gemessen 
 GND - Anschluss an 0V Programmierung 
 Hier ist ein einfaches Beispiel für die Arduino Verbinden Sie + 5V und 0V. 
 Schließen Sie Trig an Pin 13 des Arduino und Echo an Pin 12: 
 */

#define trigPin 7  // Schließen Sie Trig auf dem Modul zu pin-7 auf der Arduino
#define echoPin 6  // Schließen Sie Echo auf dem Modul zu pin-7 auf der Arduino


void setup() {
  pinMode(trigPin, OUTPUT);    // Stellen Sie den Pin an trig Ausgang
  digitalWrite(trigPin, LOW);  // Set trigPin low to start
  pinMode(echoPin, INPUT);     // setze den echoPin als Eingang
  Serial.begin(9600);          // Starten Sie eine serielle Verbindung zu den Arduino Ausgabe anzuzeigen
  delay(3000);                 // 3 Sekunden Pause, bevor wir wider anfangen
}


void loop(){
  long duration;                     // DDefinieren Sie die Variable für die Impulsdauer verwendet
  digitalWrite(trigPin, HIGH);       // Stellen Sie die Trig-pin high, um die Messung zu starten
  delayMicroseconds(10);             // wartet 10uSek.
  digitalWrite(trigPin, LOW);        // Stellen Sie die Trig-pin low, Modul soll einen Impuls senden
  duration = pulseIn(echoPin, HIGH); // Lesen die Pulslänge aus dem SR04 Modul
  duration = duration / 50;          // Konvertieren Zeit nach cm (range is 3cm - 4.5M)
  Serial.println(duration);          // Sendet den Abstand an die serielle Schnittstelle

  delay(1000);                       // 3 Sekunden Pause, bevor wir wieder anfangen
}


http://g6ejd.redirectme.net/computing/DISTANCE_display.htm
Ultrasonic.h

https://github.com/JRodrigoTech/Ultrasonic-HC-SR04/tree/master/Ultrasonic
Cytron Technologies USER MANUAL v1.0 (Mai 2013) HC-SR04 Ultrasonic Sensor
505_d_Sensor-x_Ultraschall-Sensoren § HC-SR04 Ultrasonic Sensor - USER-MANUAL_1a.pdf  10 Seite

http://playground.arduino.cc/Code/SR04


704_d_ARDUINO-x_Arduino - Eine Einführung – Popovic_2a.pdf
704_d_ARDUINO-x_Arduino - Eine Einführung – Popovic_2a.doc

300_c_popovic-x_Arduino-Tutorial für den Unterricht (34 Seiten)_1a.pdf
300_c_popovic-x_Arduino-Tutorial für den Unterricht (34 Seiten)_1a.doc


http://popovic.info/html/arduino/arduinoUno_1.html






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

Arduino HC-SR04 (Ultrasonic Sensor)

Der HC-SR04-Ultraschall-Sensor ist ein sehr billiger und guter Sensor für den Arduino.
Dieses kommt
in einem Robot Kit von Deal Extreme.
Es funktioniert durch
das Senden und Empfangen von Ultraschallimpulse, was dir die Entfernung zum nächsten Objekt ermittelt.

In diesem Entwurf werden wir das tun, werden wir einen Impuls senden, um die Erkennung ausgelöst und dann das Echo mit dem Impuls () Funktion zu hören. Die Dauer dieses zweiten Impulses ist gleich der Zeit, die der Ultraschall zur Bewältigung des Objekts zum Sensor zurücklegt und unter der
Verwendung der
Schallgeschwindigkeit kann diese Zeit auf den Abstand umgerechnet werden.

Sensor Arduino
GND GND
Echo PIN 8
Trig PIN 7
Vcc 5V


Arduino HC-SR04 (Ultrasonic Sensor)_1a.ino
// Titel: Sketch Arduino HC-SR04 (Ultrasonic Sensor)
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Arduino HC-SR04 (Ultrasonic Sensor)_1b.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// Arduino HC-SR04 (Ultrasonic Sensor)
/*
HC-SR04 ping distance sensor
 VCC to 5,0V
 GND to GND
 Echo to pin-7
 Trig to pin-8 
 */

#define echoPin 7 // Echo pin-7
#define trigPin 8 // Trigger pin-8
long duration, distance;     // Variablen für Laufzeit und Abstand halten


void
setup() {   Serial.begin(9600); // initialisieren seriellen Schnittstelle   pinMode(trigPin, OUTPUT); // initialisieren Trigger-pin   pinMode(echoPin, INPUT); // initialisieren Echo-pin }
void loop() {   /* Das folgende trigPin / Chopin-Zyklus wird verwendet,    um den Abstand des nächsten zu bestimmen Objekt     durch Prellen Schallwellen von ihm weg */   digitalWrite (trigPin, LOW); // vor dem Senden eines HIGH-Pulses ein Geben Sie einen kurzen 2us LOW Impuls   delayMicroseconds(2); // Trigger für 2us oder mehr Mikro auslösen HIGH-Puls   digitalWrite(trigPin, HIGH);   delayMicroseconds(10);   digitalWrite (trigPin, LOW);   duration = pulseIn(echoPin, HIGH); // Jetzt lesen wir die Schall-Laufzeit   distance = microsecondsToCentimeters(duration);  // Berechnung der Entfernung   Serial.print ("cm ");   Serial.print (distance);   delay(100); }

long microsecondsToCentimeters (long microseconds) {   // Die Schallgeschwindigkeit beträgt 340 m / s oder 29 Mikrosekunden pro Zentimeter   // Der Ping fährt vor und zurück, so wird der Abstand die Hälfte der zurückgelegten Wegstrecke   return microseconds / 29 / 2; }

http://blog.whatgeek.com.pt/arduino/arduino-hc-sr04-ultrasonic-sensor/

References

http://arduino.cc/en/Tutorial/Ping?from=Tutorial.UltrasoundSensor
http://arduinobasics.blogspot.pt/2012/11/arduinobasics-hc-sr04-ultrasonic-sensor.html




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

         Arduino Distance Detector HC-SR04 with a Buzzer

geschrieben 19. Februar 2015, 12.23 Uhr von M. Saifur Rahman [Update 6. April 2015, 07.22]

Dies ist eine einfache Anleitung, wie man einen Abstandsdetektor mit einem Arduino, ein HC-SR04 Ultraschallsensor zu machen, a Buzzer.
The
ultimative Ziel dieses Tutorials ist es, um den Summer-Anzeige verwenden, wie weit das Objekt von dem Ultraschallsensor.
Die für dieses Projekt benötigten Materialien sind:


(1x) Arduino Uno
(1x) Breadboard
(1x) HC-SR04 Ultrasonic Sensor
(1x) Buzzer
(1x) 330 ohm Resistors
Few  of jumper wires
The photo above shows the setup of the project.  The jumper wires should be connected as follows:




Ein Überbrückungskabel von der auf dem Arduino der 5,0 Volt-pin an der Unterseite Kanal des Steckbrett
Schließen Sie ein weiteres Schaltdraht aus einem Erdungsstift (GND-pin) auf der Arduino zum oberen Kanal des Steckbrett


Buzzer an pin-3

(Ein Ultrasonic Sensor)
Echo an pin 6
Trig an pin 7

Das Wichtigste zuerst, wir verbinden die 5 Volt und Masse-Pin mit dem Steckbrett.
Auch hier sollte der Draht in die 5,0 Volt-Pin befestigt auf den Grund Kanal des Steckbrett angeschlossen werden, während der Draht dem Erdungsstift befestigt ist, um den oberen Kanal der Steckbrett angeschlossen werden
Jetzt ist es Zeit, um die HC-SR04 Ultraschallsensor zu befestigen.
Am einfachsten ist es, den Ultraschallsensor als ganz rechts mit dem Steckbrett wie möglich zu platzieren.

Zurückkommend auf die Setup-Bild, sollten Sie den Erdungsstift auf der Ultraschallsensor auf den Boden Kanal auf dem Steckbrett zu verbinden.

Verbinden Sie dann den Echo Pin auf dem Sensor zu Pin 6 auf der Arduino.

Schließen Sie nun das Trig Stift auf dem Sensor an Pin 7 auf der Arduino und schließlich eine Verbindung auf dem Sensor die VCC-Anschluss an die 5,0 Volt-Kanal auf dem Steckbrett.

Wenn du das getan hast alles anzeigt, sollten Sie Ihre Montage wie auf dem Bild oben sehen.
Nun, da Sie die physische Einrichtung des Build abgeschlossen haben, jetzt ist es Zeit für den Code.
Ich gehe davon aus, dass Sie bereits über das Arduino Programm auf Ihrem Computer, so dass jetzt alles, was Sie tun müssen ist, kopieren, in den Code von unten
.


Arduino_Distance_Detector_HC-SR04_with_a_Buzzer_1a.ino
// Titel: Arduino Distance Detector HC-SR04 with a Buzzer
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Arduino Distance Detector HC-SR04 with a Buzzer_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// Arduino Distance Detector HC-SR04 with a Buzzer

#define trigPin 7
#define echoPin 6
#define buzzer 3
int sound = 250;


void setup() {
  Serial.begin (9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(buzzer, OUTPUT);
}


void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;

  if (distance > 30 || distance <= 0){
    Serial.println("Out of range");
    noTone(buzzer);
  }
  else {
    Serial.print(distance);
    Serial.println(" cm");
    tone(buzzer, sound);
  }
  delay(500);
}

Ich habe den Code an dieser Anzeige beigefügt.
Sie können auch herunterladen und laden Sie die Skizze, um Ihre Arduino Board.
Sobald Sie das getan haben, und Sie in Ihrem Arduino an den Computer angeschlossen haben, führen Sie den Code und Sie fertig sind.
Wenn Sie auch
alle Anweisungen befolgt, je näher man der Hand bist bringt es auf den HC-SR04

https://sites.google.com/site/shaifurcse/blog/arduinodistancedetectorwithabuzzer







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

MINT: BAUSTEINE

HC-SR04 Ultrasonic Sensor

Tragbaren Geräts zur Entfernungsmessung.
Neben dem Arduino werden ein Ultraschallsensor, ein I2C-LCD-Display ein Druckschalter und ein 9-V-Block mit Clip und Normstecker benötigt.
Die folgende Abbildung zeigt, wie das Gerät aussehen soll:




Ein "fliegender" Aufbau könnte so aussehen:

US-Sensor und Display sind über eigens dafür gefertigte Steckverbinder an den Arduino angeschlossen. Um sie herzustellen sind Buchsenleisten, Steckbrücken und etwas Lötarbeit vonnöten. Die folgende Abbildung macht hoffentlich hinreichend deutlich, wie die Teile zu verlöten sind.

Um die Anzeige nur bei Bedarf zu aktivieren, muss ein Schalter integriert werden. Wie er einzubauen ist, zeigt die folgende Abbildung:

Es ist zu empfehlen, vor dem Einbau in ein Gehäuse den Aufbau zu testen. Die folgende Abbildung zeigt, wie das geschehen kann:

LiquidCrystal_I2C.h  fehlt ! ! !


Hier der Programmcode (Sketch) mit Erklärungen:
// Titel: Tragbaren Geräts zur Entfernungsmessung HC-SR04
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Tragbaren Geräts zur Entfernungsmessung HC-SR04_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

 
#include <Wire.h>   
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27,16,2);

#define printByte(args)  write(args);  
uint8_t mu[8]  = {0,18,18,18,28,16,16,16};  
#define trigPin 7           // Trig ist an Pin 7  
#define echoPin 8           // Echo ist an Pin 8  
long dauer, strecke;

void setup() {    
pinMode(trigPin, OUTPUT);   // Pin 7 ist ein Ausgang  
lcd.init();                 // Display wird initialisiert   
lcd.backlight();            // Display wird beleuchtet  
lcd.createChar(6, mu);      // Buchstabe wird erstellt  
}  


void loop()  {  
  digitalWrite(trigPin, HIGH);    // Pin 7 ist an (Ultraschall)  
  delayMicroseconds(5);           // 5 Mikrosek. warten  
  digitalWrite(trigPin, LOW);     // Pin 7 ist aus (kein Ultraschall)

  pinMode(echoPin, INPUT);        // Pin 8 ist ein Eingang  
  dauer = pulseIn(echoPin,HIGH);  // Dauer (Schall läuft hin und zurück) wird gemessen
                                  // Aus der Dauer wird die Strecke berechnet  
strecke = 34300 * dauer / 1000000 / 2;     
if (strecke < 12){  
}

lcd.clear();            // Display wird gelöscht  
lcd.setCursor(0,0);     // Cursor wird gesetzt  
lcd.print("Distanz:");  
lcd.setCursor(9,0);     // Cursor wird gesetzt  
lcd.print(strecke);     // Strecke wird angezeigt  
lcd.setCursor(14,0);     // Cursor wird gesetzt  
lcd.print("cm");        // Einheit  
lcd.setCursor(0,1);     // Cursor wird gesetzt  
lcd.print("Dauer:");  
lcd.setCursor(9,1);     // Cursor wird gesetzt  
lcd.print(dauer);       // Dauer wird angezeigt  
lcd.setCursor(14,1);     // Cursor wird gesetzt  
lcd.printByte(6);  
lcd.setCursor(15,1);     // Cursor wird gesetzt  
lcd.print("s");         // Einheit     
delay(500);             // 0,5 Sekunden Pause  
}


Zum Schluss die Bemaßung des Gehäuses. Die grau hinterlegten Kreise und das Rechteck stehen für die nötigen Aussparungen: Ultraschallsensoren, LCD-Display und Taster. Die Größe der Aussparungen sind den konkreten Teilen anzupassen. Wir empfehlen die Verwendung von Pappe oder 0,5mm Weißblech




http://hmario.home.xs4all.nl/arduino/LiquidCrystal_I2C/


http://www.mint-unt.de/entfernungsmessung.html








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

                           ARDUINO-MINI PARKAMPEL


Arduino Mini (Quelle: Ehnicro)

Technische Daten Mini:
•    ATmega168 Mikrocontroller mit 16MHz Quarztakt
•    Programmierung über USB-Adapter (ARDUINO/USB. USB-Adapter mit FTDI-Chip)
•    512 Byte EEPROM
•    1 KB SRAM
•    16 KB FLASH (2 KB benötigt der Bootloader für sich)
•    Betriebsspannung 5V
•    14 Digitale I/Os, 6 davon können zur PWM-Erzeugung genutzt werden
•    8 analoge 10bit Eingänge
•    Versorgungsspannung 7V bis 9V




1x Arduino Pro Mini + FTDI Tool
1x HC-SR4 Ultraschallwandler
5x WS2812b Pixel LED´s

ARDUINO-MINI PARKAMPEL HC-SR04_1a.ino



// Titel: ARDUINO-MINI PARKAMPEL HC-SR04
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: ARDUINO-MINI PARKAMPEL HC-SR04_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


#include <Adafruit_NeoPixel.h>
#define NUM_PIXEL 5
#define DATA_PIN 6
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_PIXEL, DATA_PIN, NEO_GRB + NEO_KHZ800);

#define trigPin 10
#define echoPin 11
#define led 13

void setup() {
  strip.begin();
  clearStrip();
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(led, OUTPUT);

}

void loop() {
  long duration, distance;
  strip.setBrightness(150); //Pixelhelligkeit / 0 = aus / 255 = voll an

  //HC-SR4 abfrage#########################################################
  digitalWrite(led, HIGH);
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;
  digitalWrite(led, LOW);

  //Entfernung umlegen auf Strip (Mapping) ###########################################
  int d = map(distance, 0, 50, 0, NUM_PIXEL); // (min entfernung, max entfernung, min Pixel, max Pixel)
  clearStrip();
  for(uint16_t L = 0; L<d; L++) {

    strip.setPixelColor(L,wheel(((85-(L*22)) & 255))); //Farbverlauf von Rot nach Grün, erster Wert hier 85 = startfarbe, zweiter Wert hier 22 = ende endfarbe
  }
  strip.show(); // Ausgabe auf Strip
  delay(100);
}

//Farbrad################################################################
uint32_t wheel(byte WheelPos) {
  if(WheelPos < 85) {
    return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  }
  else if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  else {
    WheelPos -= 170;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

//Strip ablöschen########################################################
void clearStrip(){
  for(int i = 0; i < NUM_PIXEL; i++) {
    strip.setPixelColor(i, 0);
  }
}


http://www.arduinoforum.de/arduino-Thread-HC-SR4-Ultraschall-Abstands-Ampel-mit-WS2812b-Pixel-LED%C2%B4s







*********************************************************
Code_for_Proximity_-_Google_Docs.pdf

Arduino Distance Detector HC-SR04 with Buzzer and 5LEDs_1a.ino

// Titel: Arduino Distance Detector HC-SR04 with Buzzer and 5LEDs
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Arduino Distance Detector HC-SR04 with Buzzer and 5LEDs_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


#define trigPin 6
#define echoPin 7
#define led 12
#define led2 11
#define led3 10
#define led4 9
#define led5 8
#define buzzer 3
int sound = 250;
void setup() {
  Serial.begin (9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(led5, OUTPUT);
  pinMode(buzzer, OUTPUT);
}
void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;
  if (distance <= 200) {
    digitalWrite(led, HIGH);
    sound = 190;
  }
  else {
    digitalWrite(led,LOW);
  }
  if (distance < 150) {
    digitalWrite(led2, HIGH);
    sound = 260;
  }
  else {
    digitalWrite(led2, LOW);
  }
  if (distance < 100) {
    digitalWrite(led3, HIGH);
    sound = 270;
  }
  else {
    digitalWrite(led3, LOW);
  }
  if (distance < 50) {
    digitalWrite(led4, HIGH);
    sound = 210;
  }
  else {
    digitalWrite(led4,LOW);
  }
  if (distance < 25) {
    digitalWrite(led5, HIGH);
    sound = 190;
  }
  else {
    digitalWrite(led5,LOW);
  }
  if (distance > 200){
    Serial.println(distance);
    noTone(buzzer);
  }
  else {
    Serial.print(distance);
    Serial.println("cm");
    tone(buzzer, sound);
  }
  delay(50);
}

http://www.instructables.com/id/Arduino-Distance-Detector-with-a-Buzzer-and-LEDs/step7/The-Code/
http://forum.arduino.cc/index.php?topic=281650.0







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

                            Ultrasonic Sensor HC-SR04




Video Tutorial: http://vimeo.com/44836674

 

Arduino Distanz Sensor HC-SR04 mit 2LEDs_1a.ino


// Titel: Arduino Distanz Sensor HC-SR04 mit 2LEDs
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Arduino Distanz Sensor HC-SR04 mit 2LEDs_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


int echoPin=6;
int trigPin=7;             //set up ultrasound pins on HC-SR04
int led = 13;              //assign LED pin
int threshold = 25;
//assign threshold distance


void setup() {
  Serial.begin (9600);       //open serial communications
  pinMode(trigPin, OUTPUT);
  pinMode (echoPin, INPUT);
  pinMode(led, OUTPUT);        //describe inputs and outputs
}


void loop () {
  int duration, cm;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite (trigPin, HIGH);
  delayMicroseconds (10);
  digitalWrite(trigPin, LOW);
  duration= pulseIn(echoPin, HIGH);
  cm= duration /29 /2;

  Serial.print(cm);
  Serial.println("cm");
  delay(100);

  if (cm > threshold) {
    digitalWrite(led, HIGH);       //turn on LED
  } 
  else {
    digitalWrite(led,LOW);          //otherwise turn it off}
  }
}



Andere Version:

Arduino Distanz Sensor HC-SR04 mit 2LEDs NEU_1a.ino

// Titel: Arduino Distanz Sensor HC-SR04 mit 2LEDs NEU
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Arduino Distanz Sensor HC-SR04 mit 2LEDs NEU_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/*
HC-SR04 Ping distance sensor
 Vcc to arduino 5,0V  GND to arduino GND
 Echo to Arduino pin-13
 Trig to Arduino pin-12
 Red LED to Arduino pin-11
 Green LED to Arduino pin-10
 560 Ohm Resistor to both LEDkathode and GND power rail
 More info at: http://goo.gl/kJ8Gl
 Originalcode Verbesserungen an der Ping Skizze aus www.Trollmaker.com sourced
 Einige Codes und Verdrahtung inspiriert von http://en.wikiversity.org/wiki/User:Dstaub/robotcar
 */

#define trigPin 13
#define echoPin 12
#define led 11
#define led2 10

void setup() {
  Serial.begin (9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(led, OUTPUT);
  pinMode(led2, OUTPUT);
}

void loop() {
  long duration, distance;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;
  if (distance < 4) {            // Dies ist, wo die LED On / Off geschieht
    digitalWrite(led,HIGH);      // Als die Rote Bedingung erfüllt ist, sollte die grüne LED auszuschalten
    digitalWrite(led2,LOW);
  }
  else {
    digitalWrite(led,LOW);
    digitalWrite(led2,HIGH);
  }
  if (distance >= 200 || distance <= 0){
    Serial.println("Out of range");
  }
  else {
    Serial.print(distance);
    Serial.println(" cm");
  }
  delay(500);
}


Arduino Distanz Sensor HC-SR04 mit LED und Buzzer_1a.ino

// Titel: Arduino Distanz Sensor HC-SR04 mit LED und Buzzer
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Arduino Distanz Sensor HC-SR04 mit LED und Buzzer_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/*
HC-SR04 Ping distance sensor
 Vcc to arduino 5,0V  GND to arduino GND
 Echo to Arduino pin-6
 Trig to Arduino pin-7
 LED to Arduino pin-13
 560 Ohm Resistor to LEDkathode and GND power rail
Buzzer to Arduino pin-8
  */ int echoPin=6; int trigPin=7; int buzzerPin=8; //connect buzzer to pin 8 and ground //set up ultrasound pins on HC-SR04 int led = 13; //assign LED pin int threshold = 10; int note=60; //assign threshold distance void setup() {   Serial.begin (9600); //open serial communications   pinMode(trigPin, OUTPUT);   pinMode (echoPin, INPUT);   pinMode(led, OUTPUT);   //describe inputs and outputs } void loop () {   int duration, cm;   digitalWrite(trigPin, LOW);   delayMicroseconds(2);   digitalWrite (trigPin, HIGH);   delayMicroseconds (10);   digitalWrite(trigPin, LOW);   duration= pulseIn(echoPin, HIGH);   cm= duration /29 /2;   Serial.print(cm);   Serial.println("cm");   delay(100);   tone(buzzerPin, cm * note, 100); //play note proportional to distance }
http://westonarduino.pbworks.com/w/page/64524868/Ultrasonic%20Sensor%20HC-SR04




*********************************************************
                         US-Sensor
                                   4-Pin Ultraschall- Modul HC-SR04
                               Ultraschall Distanz Sensor HC-SR04



                                                                        1        2       3        4

Abb. 3-4    Der UltraschallSensor HC-SR04

Pin-1 Vcc         = +5Vdc  +/- 10% (Versorgungsspannung)
Pin-2 Trig (Ping) = pin-8          (Triggereingang, TTL-Pegel)
Pin-3 Echo        = pin-7          (Ausgang Meßergebnis, TTL-Pegel)
Pin-4 GND         = GND, 0V        (Masse)

505_Sensor-x_HC-SR04 Ultraschall Messmodul - Beschreibung_1a.pdf


40kHz Ultraschall-Entfernungsmesser-Modul HC-SR04 = US-020
  • Betriebsspannung: 5 Vdc
  • Betriebstemperatur: -10 bis 70°C
  • Stromaufnahme: 3..15mA
  • Öffnungswinkel: <= 15 Grad
  • Arbeitsfrequenz: 40kHz 
  • Max. Range: 450cm  (Default 3m)
  • Min. Range: 0.02m (2cm)
  • Resolution (Auflösung): 1 cm
  • Genauigkeit max. 3mm
  • max. 50 Messungen /sec. (bei Dauermessungen einer Frequenz kleiner 50Hz (20mS Intervall))
  • Ein Messintervall hat eine Dauer von 20ms, es können somit bis zu 50 Messungen pro Sekunde durchgeführt werden.
  • MeasuringAngle: 15 degree 
  • Eingangs Trigger Signal: 10us (TTL pulse)  Der Messzyklus wird ausgelöst mit einer abfallenden Flanke am Triggereingang für 10µs.
  • Ausgangs Signal: TTL low aktiv  ( L < 1,0V)
  • Echo Output Signal: Input TTL lever signal and the range in proportion
  • Das Messergebniss steht dann am Ausgang als PWM Signal zur Verfügung.

Distance (cm) = Measured Echo Time 58µsec/cm (hin und zurück)

http://wiki.iteadstudio.com/Ultrasonic_Ranging_Module_HC-SR04


Ablaufdiagramm



Anwendung:
Das Auslösen eines Messzyklus geschieht durch eine fallende Flanke am Triggereingang (Pin 2) für mindestens 10μs.
Das Modul sendet darauf nach ca. 250μs ein 40 kHz Burst-Signal für die Dauer von 200μs.
Danach geht der Ausgang (Echo, Pin 3) sofort auf H-Pegel und das Modul wartet auf den Empfang des Echos.
Wird dieses detektiert fällt der Ausgang auf L-Pegel.
20ms nach Triggerung kann eine weitere Messung stattfinden.  (Bei Dauermessung max. Meßfrequenz 50Hz)
Wird kein Echo detektiert verweilt der Ausgang für insgesamt 200ms auf H-Pegel und zeigt so die erfolglose Messung an.
Danach wartet das Modul auf die nächste fallende Flanke am Triggereingang und die Messung beginnt neu.
Die besten Messergebnisse ergeben sich bei Reflektion an glatten, ebenen Flächen.
Bei Distanzen bis 1m ist das Material der Fläche recht unkritisch.
Der Winkel zum Objekt kann bei kurzen Distanzen von unter 1m bis etwa 45° betragen.
Auch recht dünne Objekte werden zuverlässig erkannt.
Ein normaler Kugelschreiber z.B. lässt sich bis auf eine Distanz von ca. 30cm sicher erfassen.
Bei der maximalen Distanz von 3m muss schon genau gezielt werden und es sollten keine anderen Gegenstände in ähnlicher Entfernung im Sendekegel von 15° vorhanden sein.
Plusch und schallabsorbierende Materialien können nicht detektiert werden.


Ein 10 us langer Impuls am Trigger-Pin löst acht 40kHz Ultraschall Impulse aus.
Die gemessene Entfernung ist proportional zur Echo-Puls-Weite am Signal Pin und kann und kann durch die folgende Formel berechnet werden.

34342cm/sec   1000000 / 34342 = 29,11 x 2 = 58,24 µsec/cm

Distanz = Pulsweite Echo-Pin / 29,11 / 2
(Die Schallschwindigkeit beträgt ca. 29 us/cm und das Signal muss den doppelten Weg zum Hindernis und zurück laufen).
Man könnte die Genauigkeit noch steigern, in dem man einen Temperatursensor verwendet und die Anhängigkeit der der Schallgeschwindigkeit von der Temperatur berücksichtigen.
Ein kurzer Ultraschallimpuls zu der Zeit 0 übertragen wird, durch ein Objekt reflektiert wird. D
er Sensor empfängt dieses Signal und wandelt es in ein elektrisches Signal um.
Der nächste Impuls kann übertragen werden, wenn das Echo verklungen ist.
Diese Zeit wird als Zykluszeit.
Die Zykluszeit empfehlen sollte nicht weniger als 50 ms sein.
Wenn ein 10 us Breite Triggerimpuls an den Signalstift gesendet, der Ultraschallmodul ausgibt acht 40 kHz Ultraschallsignal und erkennt das Echo zurück.
Der gemessene Abstand ist proportional zu der Echoimpulsbreite und kann durch die obige Formel berechnet werden.
Wenn kein Hindernis erkannt wird, wird der Ausgangspin geben 38ms Signal mit hohem Pegel.

http://www.elecfreaks.com/store/download/product/Sensor/HC-SR04/HC-SR04_Ultrasonic_Module_User_Guide.pdf



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

c = Schallgeschwindigkeit (Ausbreitungsgeschwindigkeit der Schallenergie)

http://de.wikipedia.org/wiki/Schallgeschwindigkeit


Berechnen der Schallgeschwindigkeit in Luft und die wirksame Temperatur
http://www.sengpielaudio.com/Rechner-schallgeschw.htm


Normaltemperatur  T = 293,15K bei 20°C
In trockener Luft bei 1000mbar und 0 °C ist c = 331,2 m/sec
In trockener Luft bei 1013mbar und 0 °C ist c = 331,2 m/sec
Der mittlere Luftdruck auf Meereshöhe ist 101325 Pa.
Jedoch ist diese Angabe bei der Schallgeschwindigkeit unbedeutend.
Dazu brauchen wir immer die Temperaturangabe.

Bei 0°C ist Luftdichte ρ0 = 1,293 kg/m3, Z0 = 428 N·s/m3 und c0 = 331,5 m/s
Bei 20°C ist Luftdichte ρ20 = 1,204 kg/m3, Z20 = 413 N·s/m3 und c20 = 343 m/s

Beispielsweise ist bei 20 °C und 100 % Luftfeuchtigkeit die Schallgeschwindigkeit um 0,375 % höher als bei 20 °C und 0% Luftfeuchtigkeit.



        c = 331,2 x (1 +   T/273) hoch 0,5
-10°C   c = 331,2 x (1 + -10/273) hoch 0,5 = 325,07  ODER 331,2 +  0,613 x -10°C = 325,07m/sec
  0°C   c = 331,2 x (1 +   0/273) hoch 0,5 = 331,20
 20°C   c = 331,2 x (1 +  20/273) hoch 0,5 = 343,12  ODER 331,2 +  0,596 x  20°C = 343,12m/sec  entspricht 1235,2 km/h
 20°C   c = 331,5 x (1 +  20/273) hoch 0,5 = 343,42  ODER 331,2 +  0,596 x  20°C = 343,42m/sec
 40°C   c = 331,2 x (1 +  40/273) hoch 0,5 = 354,63  ODER 331,2 +  0,586 x  40°C = 354,63m/sec
Diese Näherung gilt im Temperaturbereich von −20 °C bis +40 °C mit einer Genauigkeit von besser als 99,8 %.

34342cm/sec   1000000 / 34342 = 29,11 x 2 = 58,24 µsec/cm

In SI-Einheiten ist bei trockener Luft und 20°C  die Schallgeschwindigkeit c = 343 m/s.

Schallgeschwindigkeit in Abhängigkeit von der Lufttemperatur

Die Schallgeschwindigkeit ist so gut wie nur von der Temperatur abhängig.
Die Schallgeschwindigkeit ändert sich deutlich mit der Temperatur, nur 0,375% mit der Luftfeuchtigkeit − aber nicht mit dem Luftdruck.
Der ändernde Luftdruck ändert nicht die Schallgeschwindigkeit ! ! !

T °C   c

+35     352,09
+30     349,23
+25     346,33
+20     343,42 m/sec     c ≈ 331,5 + (0,6 · ϑ) = 331,5 + (0,596 · 20) = 343,42 m/s.
+15     340,48
+10     337,51
+  5     334,52
    0     331,50 m/sec
−  5     328,45
−10     325,37
−15     322,26
−20     319,13



Die Entfernung eines Blitzes und damit eines Gewitters lässt sich durch Zählen der Sekunden zwischen dem Aufleuchten des Blitzes und dem Donnern abschätzen.
Näherung:
Der Schall legt in der Luft einen Kilometer in etwa 3 Sekunden zurück, die Anzahl der gezählten Sekunden durch drei geteilt, ergibt daher die Entfernung des Blitzes in Kilometern.

https://www.uni-due.de/physik/fbphysik/probestudium/Skripte/Anleitung.A6.pdf







********************************************************
                   Messgenauigkeit:

Die systembedingte Messgenauigkeit beträgt ca. 3mm und hängt mit der internen Abtastrate des Moduls zusammen.
Ein weiterer Faktor ist die Temperaturabhängigkeit der Schallgeschwindigkeit in Luft.
Näherungsweise kann man die Schallgeschwindigkeit in Abhängigkeit der Temperatur im Bereich von -20°C bis +40°C mit folgender Formel berechnen:

Theta = Umgebungstemperatur in °C
Für 20°C Raumtemperatur ergibt sich also: c = 331,5 + ( 0,6 x 20 ) = 343,5 m/s.
Die folgende Tabelle enthält einige Werte die rechnerisch für die Laufzeit zu erwarten sind:

Entfernung zum Objekt[cm]   Laufzeit[ms] bei 20°C   Laufzeit[ms] bei 0°C
2                           0,117                   0,121
10                          0,583                   0,603
50                          2,915                   3,017
100                         5,831                   6,033
200                        11,662                  12,066
300 (max. Dist.)           17,492                  18,100


Es zeigt sich das bei 20°C Temperaturdifferenz ein Fehler von 3,4% entsteht.
Bei der Verwendung im Freien und Messung von größeren Distanzen wäre also zu überlegen ob eine Temperaturkompensation sinnvoll ist.


505_d_Sensor-x_HC-SR04 Ultraschall Messmodul - Beschreibung_1a.pdf





*********************************************************
                  US-Entfernungsmesser
                             Pegel- und Distanzmessgerät mit Alarmfunktion


      Temperaturabhängigkeit der Schallgeschwindigkeit          


505_d_Sensor-x_140209-11 Pegel- und Distanzmessgerät § US-Sensor HC-SR04 US-020 SRF02_1a.pdf







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





*********************************************************
Abstände mit Ultraschall-Sensor messen.

Messungen von Entfernungen mit Echos von Schallsignalen

3.1    Abstände mit Ultraschall messen Ping)))
Ping    1, 2, 3 ...8  40kHz-Impulse  Pong!
Ein Ultraschallsensor sendet einen Ton aus und misst dann, wie lange es dauert, bis der Schall reflektiert wird.
Da bekannt ist, dass sich Schall mit einer Geschwindigkeit von ca. 343,42 m/s (bei 20 °C) bewegt, kann ein Programm aus dieser Zeit die Entfernung berechnen.
Heutzutage gibt es viele preisgünstige Ultraschallsensoren, die dem Ping-Sensor von Parallax nachempfunden sind (siehe Abb. 3-1).
Weiter hinten in diesem Kapitel finden Sie auch Code für einen dieser preiswerten Sensoren, den HC-SR04 (siehe Abschnitt 3.2).
Um mit den ganzen Ping-ähnlichen Sensoren umgehen zu können, ist es jedoch sinnvoll, sich zunächst einmal mit dem Original vertraut zu machen, weshalb wir Ihnen im nächsten Abschnitt Code dafür zeigen.
Außerdem haben viele Universitäten sowie Bastlerclubs oder HackerSpaces Ping-Sensoren in ihrer Sammlung — auch deshalb ist es gut, sich damit auszukennen.
Wie ein Ultraschallsensor Entfernungen misst, erfahren Sie in Abschnitt 3.2.3.
Ping ist ein älterer, weitverbreiteter Sensor von Parallax.
Im Vergleich mit den Alternativen ist er mit ca. 30 € recht teuer.
Wenn Sie viele Abstandssensoren brauchen, können Sie auch auf die billigeren HC-SR04 ausweichen.
Der ähnliche HC-SR04 kostet nur € 2,- bis € 4,-  und der einzige Konfigurationsunterschied zwischen Ping und HC-SR04 besteht in einem Pin (der HC-SR04 verwendet einen Pin, um den Sendeimpuls auszulösen, und einen anderen, um das Echo zu lesen).
Der Code für diese beiden Sensoren ist fast identisch.

3.1.1    Code und Schaltung für den Ping am Arduino
Abbildung 3-2 zeigt den Anschluss des Ping-Sensors an den Arduino. Bauen Sie die Schaltung, kompilieren Sie dann in der Arduino-IDE den Code und laden Sie ihn hoch.

Den Beispielcode können Sie von http://www.dpunkt.de/sensoren herunterladen.

Um die Messwerte anzuzeigen, verwenden Sie den seriellen Monitor (Arduino IDE > Tools > Serial Monitor). Falls statt Text nur wirres Zeug erscheint, prüfen Sie, ob Sie im Code (Serial.begin) und im seriellen Monitor der Arduino-IDE dieselbe Geschwindigkeit (in bit/s oder Baud) angegeben haben.
Obwohl das Beispiel sehr viel Code umfasst, lässt es sich leicht zur Entfernungsmessung in Ihren eigenen Projekten verwenden. Kopieren Sie einfach die Kernteile des Codes (die Funktion distanceM() und die globalen Variablen) in Ihr eigenes Programm. Dann können Sie Abstände mit der folgenden Codezeile messen:

int d=distanceM();

Da der Ping auf das Echo des ausgesandten Schalls lauscht, ist seine Platzierung sehr wichtig. Wenn Sie immer denselben Messwert erhalten (z. B. immer 2 cm), prüfen Sie, ob der Schallkegel nicht an unvorhergesehener Stelle reflektiert wird, etwa am Steckbrett oder am Tisch. Setzen Sie den Ping am besten am Rand des Steckbretts ein, damit Letzteres keine Echos verursacht.
Mit einem Servo-Verlängerungskabel (männlich/weiblich) können Sie den Ping auch bequem weiter weg vom Arduino platzieren. Da der Ping nur drei Pins aufweist, ist ein solches Kabel ideal geeignet.



3.2    Ultraschallsensor HC-SR04

Der HC-SR04 ähnelt dem Ping, ist aber für einen Bruchteil des Preises erhältlich.
Auch der Code ist fast identisch mit dem für den Ping, wobei der HC-SR04 jedoch getrennte Pins zum Auslösen des Schallsignals und zum Lauschen auf das Echo verwendet.
Ausführliche Erläuterungen zum Code erhalten Sie in Abschnitt 3.1.1 bzw. Abschnitt 3.1.2.
Die Erklärungen in diesem Abschnitt beschränken sich auf die Unterschiede zwischen den Sensoren.



3.2.1    Code und Schaltung für den HC-SR04 am Arduino
Bauen Sie die Schaltung wie in Abbildung 3-5 gezeigt und laden Sie den Code hoch.


Listing 3-3 Ultraschall- Modul HC-SR04 zur Abstand Messung_1a.ino

// Titel: Listing 3-3 Ultraschall- Modul HC-SR04 zur Abstand Messung
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Listing 3-3 Ultraschall- Modul HC-SR04 zur Abstand Messung_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/*
Vcc  = +5Vdc
Trig (Ping) = pin-8
Echo = pin-7
GND  = GND
 */

// hc_sr04.ino 
// Gibt Entfernung auf dem seriellen Monitor aus
int trigPin = 8; int echoPin = 7; float v=331.5+0.6*20; // Berechnet die Schallgeschwindigkeit v für eine Umgebungstemperatur von 20 °C.
// Wenn die Umgebungstemperatur erheblich davon abweicht,
// ersetzen Sie 20 durch den entsprechenden Celsius-Wert.
// Die Geschwindigkeit beläuft sich auf ca. 343,5 m/s oder 1236,6 km/h.
void setup(){   Serial.begin(115200);   pinMode(trigPin, OUTPUT); // Trigger-Pin Ausgang // Beim Ping sind wir nicht der üblichen Vorgehensweise gefolgt,
// den Pinmodus in der Funktion setup() festzulegen, da wir ihn ständig ändern mussten,
// denn der Ping verwendet denselben Pin, um den Impuls auszulösen und auf das Echo zu lauschen.
// Beim HC-SR04 dient der Pin Tri g dazu, das Schallsignal auszulösen.
  pinMode(echoPin, INPUT); // Echo-Pin Eingang   // Der Pin Echo gibt die Dauer bis zum Eintreffen des Echos als Pulsbreite zurück. } float distanceM() {    // Sendet Schallimpuls   digitalWrite(trigPin, LOW);   delayMicroseconds(3); // Wartet 3us, bis der Pin einen stabilen Zustand erreicht hat; 1 us = 1 Millionstel Sekunde = 1 x 10-6 s = 0,000001 s.   digitalWrite(trigPin, HIGH);   delayMicroseconds(5); // Sendet einen sehr kurzen Schallimpuls von 5 us = 5 x 10 hoch -6 sec.   digitalWrite(trigPin, LOW);    // Lauscht auf Echo   float tUs = pulseIn(echoPin, HIGH); // mißt (in Mikrosekunden), wie lange es dauert, bis pingPin (D2) den Zustand LOW einnimmt.   float t = tUs / 1000.0 / 1000.0 / 2;   // Rechnet die Werte in Sekunde um
// Beachten Sie, dass wir statt des Integers 1000 die Fließkommazahl 1000.0 verwenden,
// um als Ergebnis eine Fließkommazahl zu bekommen.
// Die hier berechnete Zeit für eine Richtung beträgt die Hälfte der Zeit
// für den Hin- und Rückweg des Schallsignals.
  float d = t*v; // Entfernung im Meter ist Zeit mal Geschwindigkeit.   return d*100; // Entfernung im Zentimeter } void loop() {   // Abgesehen von den Änderungen in setup() sieht das Hauptprogramm
// bei der Verwendung des HC-SR04 größtenteils genauso aus wie beim Ping.
  int d=distanceM(); // mißt den Abstand und speichert ihn in der neuen Variablen d.   Serial .println(d, DEC); // gibt den Wert von d auf dem seriellen Monitor aus.   delay(200); // 200ms - bauen Sie in Schleifen immer Verzögerungszeiten ein. Wenn Sie den Sketch ohne Pause laufen lassen, strapazieren Sie damit die CPU des Arduino und verschwenden Strom (alles so schnell wie möglich zu erledigen, kann auf einem Einkernprozessor 100 % des verfügbaren Stroms in Anspruch nehmen). }
Listing 3-3    hc-sr04.ino





*********************************************************
       Ultraschall Distanz Sensor HC-SR04
Ein äußerst günstiger und doch recht genauer Entfernungssensor ist der HC-SR04. Er ist schon für ab 4 € zu haben.



Funktion

Ein 10 us langer Impuls am Trigger-Pin löst 8 40kHz Ultraschall Impulse aus. Die gemessene Entfernung ist proportional zur Echo-Puls-Weite am Signal Pin und kann und kann durch die folgende Formel berechnet werden.
Distanz = Pulsweite Signal-PIN / 29 /2
(Die Schallschwindigkeit beträgt ca. 29us/cm und das Signal muss den doppelten Weg zum Hindernis und zurück laufen). Man könnte die Genauigkeit noch steigern, in dem man einen Temperatursensor verwendet und die Anhängigkeit der der Schallgeschwindigkeit von der Temperatur berücksichtigen.

Listing_Ultraschall_Distanz_Sensor_HC-SR04_1a.ino


// Titel: Listing Ultraschall Distanz Sensor HC-SR04
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Listing Ultraschall Distanz Sensor HC-SR04_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/*
Vcc  = +5Vdc
 Trig (Ping) = pin-13
 Echo = pin-12
 GND  = GND
 */

// HC-SR04.ino 
// Gibt Entfernung auf dem seriellen Monitor aus

int pingPin = 13;  // Trigger ist pin-13
int inPin = 12;    // Echo ist pin-12

void setup() {   Serial.begin(9600);// Serielle kommunikation starten, damit man sich später die Werte am Serial-Monitor ansehen kann } void loop(){   // Variablen zur Laufzeit der Ping und der Abstand Ergebnis in Zoll und Zentimeter zu etablieren:   long duration, inches, cm; // Das Wort inches, cm ist jetzt die Variable   pinMode(pingPin, OUTPUT); // "trigger" (pin-13) ist ein Ausgang   digitalWrite(pingPin, LOW);   delayMicroseconds(2); // vorher Geben Sie einen 2ms LOW Impuls, um eine saubere HOCH-Puls zu gewährleisten   digitalWrite(pingPin, HIGH);   delayMicroseconds(10); // Der PING))) wird mit einem High Impuls von 10 Mikrosekunden ausgelöst   digitalWrite(pingPin, LOW);   // Auf den Empfang der Echos von einem Objekt ein HIGH   // dessen Dauer ist die Zeit (in Mikrosekunden) von der sendenden   // des Ping:   // Die gleichen Pin wird verwendet, um das Signal von dem PING lesen))) .   pinMode(inPin, INPUT); // "echo" (pin-12) ist ein Eingang   duration = pulseIn(inPin, HIGH); // mit dem Befehl "pulseIn" zählt der Mikrokontroller die Zeit in Millisekunden,   inches = microsecondsToInches(duration);   // Zeit in einem Abstand zu konvertieren   cm = microsecondsToCentimeters(duration);   Serial.println(cm, DEC); // WERT auf dem Serial-Monitor ausgeben   delay(100); // Pause 0,1 Sek. } long microsecondsToInches(long microseconds){   // Nach Parallax Datenblatt für den PING))), gibt es   // 73,746 Mikrosekunden pro Inch (dh Schall bei 1130 Fuß pro Sekunde)
// Dies gibt den Abstand vom Ping, Outbound
  // und Rückkehr reiste, so dass wir durch 2 teilen, um den Abstand des Hindernisses zu bekommen.   return microseconds / 74 / 2; } long microsecondsToCentimeters(long microseconds){   // Die Schallgeschwindigkeit ist 340 m / s oder 29 Mikrosekunden pro Zentimeter .
// Der Ping fährt hin und zurück, so, um den Abstand des Objekts
// wir die Hälfte der zurückgelegten Strecke zu finden.
  return microseconds / 29 / 2; }
Listing von
http://www.robodino.de/2011/12/ultraschall-distanz-sensor-hc-sr04.html







*********************************************************
3.2.3 Echoberechnungen
Bei einem Gewitter können Sie die Entfernung zu der Stelle, an der der Blitz einschlägt, anhand der Zeit bestimmen, die zwischen Blitz und Donner vergeht. Zählen Sie die Sekunden nach dem Aufflammen des Blitzes.
Jede Sekunde entspricht einer Entfernung von 333 m zum Blitz. (Die genaue Zahl hängt von der Lufttemperatur ab, worüber wir in Kürze noch sprechen werden.)
Jetzt müssen wir ein bisschen rechnen: 333 m/s x 3 s = 1 km.
Das heißt, dass sich der Schall in drei Sekunden ungefähr einen Kilometer fortbewegt.
Das Licht sehen wir praktisch sofort, aber der Schall braucht eine gewisse Zeit, bis er unser Ohr erreicht.

Ultraschallsensoren können gewöhnlich Entfernungen zwischen 3 cm und 6 m messen.
Ultraschall-Entfernungsmesser aus dem Werkzeugfachhandel haben eine größere Reichweite von ca. 20 m, da sie über einen Kegel zur Schallprojektion und ein Thermometer zur Kalibrierung auf die Schallgeschwindigkeit in der aktuellen Lufttemperatur verfügen.

34342cm/sec   1000000 / 34342 = 29,11 µsec/cm
Um einen Zentimeter weit zu kommen, braucht der Schall nur sehr kurze Zeit, nämlich ca. 30 Mikrosekunden, also 30 Millionstel einer Sekunde.
Wie kommen wir auf diese Zahl?
Bei schwierigen Problemen, insbesondere solchen, bei denen es um sehr kleine oder sehr große Zahlen geht, ist es oft hilfreich, sie anhand eines vergleichbaren Problems mit vertrauten, alltäglichen Größenordnungen zu betrachten.
Nehmen wir beispielsweise an, ich fahre zwei Stunden lang (Zeit t) mit einer Geschwindigkeit (v) von 50 km/h.
Das klingt nach nervtötender Fahrerei, aber immerhin können wir mit t und v die Entfernung d berechnen:
t = 2 h
v = 50 km/h
d = t*v
d = 2 h * 50 km/h
d = 2 * 50 km * h/h = 100 km
Das war einfach!
Wir wissen jetzt also, dass zwei Stunden in diesem System 100 km entsprechen.
Nun wenden wir diese Formel auf sehr kurze Zeitdauern (3,33 Millisekunden bzw. ms) und sehr viel höhere Geschwindigkeiten an und benutzen die Basiseinheiten Meter und Sekunde.
(Das Präfix milli bedeutet ein Tausendstel, eine Millisekunde ist also eine Tausendstelsekunde.)
t = 3,33 ms = 0,00333 s
v = 330 m/s
d = t * v = 0,00333 s * 330 m/s = 1,10 m
Auf diese Weise berechnen Sie in Ihrem Programm die Entfernung anhand der Messwerte des Ultraschallsensors:
Wenn der reflektierte Schall 3,33 ms gebraucht hat, um zum Sensor zurückzukehren, hat er 1,1 m zurückgelegt.
Andere Personen verwenden in ihrem Code manchmal auch eine »Schrittdauer« für Schall.
Statt mit der Geschwindigkeit in Metern pro Sekunde wird in vielen Programmen mit dem Kehrwert in Sekunden pro Meter gerechnet (oder wie im folgenden Beispiel in Millisekunden pro Meter):
1/v = 1/(330 m/s) = 0,00303 s/m = 3,03 ms/m
Der Schall braucht also ca. 3 ms, um einen Meter zurückzulegen.
Wenn es warm ist, bewegt sich der Schall schneller vorwärts.
Schließlich ist Schall nichts anderes als eine Luftschwingung, und solche Schwingungen können sich besser fortpflanzen, wenn die Luftmoleküle bereits durch die Wärme in Schwingungen versetzt sind. Wenn Sie in einer warmen Gegend leben, dann beneiden wir Sie, weil Sie weniger Kalibrieraufwand für die Messung betreiben müssen. Hier im Norden von Finnland kann es drinnen +22 °C sein und draußen -40 °C. Eine so gewaltige Temperaturdifferenz von über 60 °C wirkt sich deutlich auf die Messgenauigkeit aus.
Die folgende Formel gibt den Zusammenhang zwischen der Temperatur T und der Schallgeschwindigkeit v an:
v = 331,5 + (0,596 · 20) = 343,42 m/s.

Mit dieser Formel können Sie einen für praktische Anwendungen ausreichend genauen Wert für die Schallgeschwindigkeit berechnen (343,42 m/s bei 20 °C).
Wenn Sie Spaß daran haben, können Sie auch noch eine Kalibrierung für viele weitere Faktoren vornehmen.
Wenn Sie mitten in der Sahara eine Wäscherei betreten, bietet sich auch eine Kalibrierung nach der Luftfeuchtigkeit an.
Allerdings nehmen handelsübliche Ultraschall-Entfernungsmesser nur eine Kalibrierung nach der Temperatur vor.

In einem Programm sollten Sie solche Berechnungen an den Anfang des Codes stellen.
Der Arduino und der Raspberry Pi können die Werte augenblicklich ausrechnen, und Berechnungen außerhalb von loop () werden ohnehin nur ein einziges Mal durchgeführt.
Versehen Sie solche Berechnungen auf jeden Fall mit Kommentaren.
Wenn Sie einige Wochen später versuchen, aus Ihrem Code schlau zu werden, werden Sie dankbar dafür sein.

3.2.4 Praxisexperiment: Unsichtbare Objekte
Einen Ultraschallsensor können Sie ganz einfach täuschen, sodass er glaubt, es befände sich nichts vor ihm.
Montieren Sie den Sensor an einer »dritten Hand« und richten Sie ihn auf ein massives, glattes Objekt.
Laden Sie den Code hoch und öffnen Sie den seriellen Monitor, wie Sie es schon bei den früheren Versuchen in diesem Kapitel getan haben.
Sie sollten jetzt normale Entfernungsangaben lesen können.
Stellen Sie nun ein weiches Kissen, ein Plüschtier oder Ähnliches zwischen den Sensor und das massive Objekt (siehe Abb. 3-7).
Zeigt der serielle Monitor das massive Objekt immer noch an?
Eine weitere Achillesferse für Ultraschallsensoren sind schiefe Ebenen.
Nehmen Sie das weiche Objekt wieder weg und beginnen Sie das glatte Objekt vor dem Sensor zu kippen. Beobachten Sie dabei den seriellen Monitor.

Warum treten diese Phänomene auf?
Weiche Objekte (wie unser Monty-Python-Killerkaninchen in Abbildung 3-7) schlucken so viel Schall, dass es kein ausreichendes Echo mehr gibt.
Schiefe Ebenen reflektieren zwar den Schall, aber in die falsche Richtung (nicht zurück zum Sensor).
Auf eine ähnliche Weise narren Stealth-Flugzeuge das gegnerische Radar.






*********************************************************
Schallgeschwindigkeit = c

Anwendungen:
Für Abstandsmessungen wird die Laufzeit des Schalls zwischen dem Sendeimpuls und dem von einer Oberfläche reflektierten Echo mit Hilfe eines Taktgebers gemessen.
Bei bekannter Schallgeschwindigkeit erhält man hieraus den Abstand
 Die Schallgeschwindigkeit in Luft ist abhängig von der Temperatur T in °C
c = 331,3 x (1 + T/273) hoch 0,5
Daher muß dieser Einfluß über einen externen Temperatursensor oder eine normierte Referenzstrecke kompensiert werden.
Der Einfluß von Luftdruck und Luftfeuchte ist derart gering, daß er für technische Anwendungen zu vernachlässigen ist.
Ultraschall-Abstandssensoren können je nach Frequenz bei Distanzen bis 30 m eingesetzt werden.
Bei kleinen Abständen lassen sich durchaus Genauigkeiten von unter 0,1 mm erreichen.
Anwendungen ergeben sich nicht nur bei der Abstandsmessung von z. B. transparenten oder weichen Objekten (Gummi, Schäume), dem Einsatz als Näherungsschalter  sowie bei der kontaktlosen Füllstandsmessung von Schüttgütern oder Flüssigkeiten, sondern auch bei der Dickenmessung  von Platten, Rohren, Schläuchen, Folien und Beschichtungen.
Interessante Applikationen sind ein Ortungssystem für fahrerlose Transportfahrzeuge, die Kollisionsüberwachung in der Robotik.
Die wichtigste Anwendung von Ultraschallsensoren stellt hingegen die zerstörungsfreie Werkstoffprüfung dar, die zuerst für metallorientierte Fertigungsprozesse entwickelt wurde, wobei hier analoge Handgeräte zur Defekterkennung eingesetzt werden.
Die Entwicklung von „Neuen Werkstoffen", wie Faserverbundwerkstoffen (z. B. CFK — kohlenstoffaserverstärkter Kunststoff), erhöht die Anforderungen an die Ultraschallprüfung und die nachgeschaltete Auswertung, weil Inhomogenität und Anisotropie als zusätzliche Einflüsse hinzukommen.
Die im Vergleich zu Metallen wesentlich höhere Schalldämpfung durch Streuung und Absorption muß bei der Auswahl der Anlagenkomponenten berücksichtigt werden.
Allerdings sind die bisher verfügbaren Ultraschallgeräte schwerpunktmäßig für die Einzelprüfung geringer Stückzahlen konzipiert worden.
Auch bei der Ultraschallprüfung setzt sich die Digitaltechnik durch.
Die quantitative Auswertung der Ultraschalldaten kann nur mit Hilfe eines Rechners sinnvoll durchgeführt werden, womit verschiedene bildhafte Darstellungsformen, die Ausgabe und Archivierung der Prüfbefunde sowie eine nachgeschaltete computergestützte Bildverarbeitung möglich ist.






*********************************************************
Ultraschall Distanz Sensor HC-SR04

Der Prinzip der Messung ist recht einfach: Es wird ein Ultraschall-Signal gesendet (40 kHz Ultraschall, ein Burst von ca. 200 Mikrosekunden Dauer, ausgelöst durch ein HIGH (mindestens 10 Mikrosekunden) am 'Trigger'-Eingang). Danach geht der 'Echo'-Pin auf HIGH und nach dem Eintreffen eines Echos (falls es denn ankommt) wird wieder auf LOW geschaltet. Die Zeit wird gemessen, durch zwei geteilt (die Strecke muss der Schall in beide Richtungen passieren) und wieder geteilt durch 29 (Entfernung in cm, die Ultraschal in einer Mikrosekunde zurücklegt). Das Egebnis ist die ungefähre Entfernung in cm.

Die Genaugkeit soll ca. 0,3 cm betragen, der Messbereich liegt laut Dokumentation bei 2 bis 400-500 cm. Mein Exemplar schafft jedoch nur etwas über drei Meter, danach werden die Rückgabewerte instabil oder das Echo bleibt ganz aus. In letztem Fall geht der 'Echo'-Ausgang nach 200ms auch auf LOW und zeigt dadurch eine erfolglose Messung an. Nach der Messung benötigt der Sensor eine Pause von ca. 20 Mikrosekunden. Die besten Messergebnisse ergeben sich bei Reflektion an glatten, ebenen Flächen. Bei Distanzen bis 1m ist das Material der Fläche recht unkritisch. Der Winkel zum Objekt kann bei kurzen Distanzen von unter 1m bis etwa 45° betragen. Auch recht dünne Objekte werden zuverlässig erkannt.

Die Betriebsspannung beträgt 5V, die Stromaufnahme liegt bei ca. 15mA.

Im einfachsten Fall sieht die Ansteuerung etwa folgendermaßen aus:

Einfacher Ultraschall Distanz Sensor HC-SR04_1a.ino

// Titel: Einfacher Ultraschall Distanz Sensor HC-SR04
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Einfacher Ultraschall Distanz Sensor HC-SR04_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/*
Vcc  = +5Vdc
 Trig (Ping) = pin-11
 Echo = pin-10
 GND  = GND
 */

// Das Programm benutzt den Ultraschallmodull HC-SR04 um Entfernungen zu messen.
// Gibt Entfernung auf dem seriellen Monitor aus

int TrigPin = 11;
int EchoPin = 10;

void setup(){  
  Serial.begin(9600);  
  pinMode(TrigPin,OUTPUT);  
  pinMode(EchoPin,INPUT);
}

void loop(){  
  int distance, duration;    
  digitalWrite(TrigPin,HIGH);  
  delayMicroseconds(11);  
  digitalWrite(TrigPin,LOW);  
  duration = pulseIn(EchoPin, HIGH);  // mit dem Befehl "pulseIn" zählt der Mikrokontroller die Zeit in Millisekunden,
  duration = duration/29/2;   // In cm umrechnen. Schalgeschwindigkeit ist 340 m/s oder 29 Microseconden per cm.      

  Serial.print(duration);  
  Serial.print("cm");  
  Serial.println();  
  delay(1000);
}





LCD-Entfernungsmesser
Bei der Suche nach Beispielen habe ich auch eine bessere Alternative zum 'alles selbst machen' gefunden.
Unter http://code.google.com/p/arduino-new-ping/ kann eine bequemm zu benutzende Bibliothek heruntergeladen werden.
Sie bietet u.a. die Möglichkeit, ein Durchschnittswert mehreren Messungen zu ermitteln.
Dadurch werden kleine Abweichungen und Zufallsfehler weitgehens 'herausgerechnet'.
Auf dieser Basis habe ich ein Sketch für ein LCD-Entfernungsmesser entwickelt.

LCD-Entfernungsmesser US-Modul HC-SR04 mit LCD-Display_1a.ino

Fehler beim Kompilieren

// Titel: LCD-Entfernungsmesser US-Modul HC-SR04 mit LCD-Display
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: LCD-Entfernungsmesser US-Modul HC-SR04 mit LCD-Display_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

/* Sonar_LCD, Version 1.0, Datum: 12.08.2013, Alexander Schulz
 Das Programm benutzt den Ultraschallmodull HC-SR04 um Entfernungen zu messen.
 Die gemessene Entfernung wird auf einem per I2C angeschlossenen LCD angezeigt.
 Verdrahtung (UNO, Nano...)
 
 HC-SR04:
 Sensor Trig pin an pin-11
 Sensor Echo pin an pin-10
 Sensor VDD pin an 5V
 Sensor GND pin an GND
 
 LCD wird per I2C-Modul an I2C Bus (A4, A5) angeschlosen.
 */


#include 
#include <LiquidCrystal_I2C.h>
#include

// Setup LCD-Shield
LiquidCrystal_I2C  lcd(0x20,16,2);  //  I2C Addresse: 0x20  LCD:  16x2
#define TRIGGER_PIN  11             // Arduino-Pin verbunden mit dem Trigger-Pin des Ultraschall-Sensors.
#define ECHO_PIN     10             // Arduino-Pin verbunden mit dem Echo-Pin des Ultraschall-Sensors.
#define MAX_DISTANCE 500            // Mxaimale beabsichtigte Entfernung (in cm). Der Sensor liefert max. ca. 400-500cm.
// NewPing setup
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup


void setup(){
  // Display initialisieren
  lcd.init();
  lcd.backlight();
  lcd.home();
  lcd.print("Sonar v1.0");
  lcd.setCursor(0,1);
  lcd.print("Initializing...");
  delay(1000);
  lcd.clear();
}


void loop() {
  // Ermittlung der Entfernung mittels Bildung eines Durchschnittswertes mehrerer Messungen
  unsigned int uS = sonar.ping_median(7);
  lcd.home();
  lcd.print("Dist: ");
  lcd.print((float)uS / US_ROUNDTRIP_CM); // In cm umrechnen (0 steht für 'Entfernung zu weit')
  lcd.print(" cm  ");
  delay(100);
}

http://www.s6z.de/cms/index.php/arduino/sensoren/20-ultraschallsensor-hc-sr04




*********************************************************
      Parallax Ping))) Ultraschall-Sensor

Das folgende Beispiel ist eine einfache Implementierung, die einfach zu verstehen und zu groß für einfaches Testen ist. Doch langsam ist, soll nicht von Interrupt-Code ausgeführt werden, und nicht die pulseIn Anruf gebunden durch Zugabe von "38000" ist oder was auch immer die passende maximale Wartezeit (in Mikrosekunden) für Ihren Sensor. Mit anderen Worten: Dieser Code kann sich vorstellen, um eine Verzögerung von 1 Sekunde nach dem Worst-Case-Timeout auf pulseIn.
Wenn Sie effizienter Code, der von Unterbrechungen ausgeführt werden kann, und kann verwendet werden, um mehrere Sensoren zur gleichen Zeit sprechen werden müssen, sehen Sie sich NewPing von

Einfaches Beispiel
Dieser Code gibt den Abstand in Zoll ... Ich denke, es ist genauer als andere Code ich online gesehen und gibt mehr brauchbare Ergebnisse. Entfernen Sie die * .39 bis cm statt Zoll zurück. Sie könnten
float ultrasoundValue = 0;  zu machen; aber dann kann man nicht drucken Sie es, wenn Sie es in eine andere Art zu übertragen, aber es ist für die weiteren Berechnungen verwendet werden könnten.


// Titel: Parallax Ping))) Ultrasonic Sensors
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: Parallax Ping))) Ultrasonic Sensors_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567


unsigned long echo = 0;
int ultraSoundSignal = 9;                    // Ultrasound signal pin
unsigned long ultrasoundValue = 0;


void setup(){
  Serial.begin(9600);
  pinMode(ultraSoundSignal,OUTPUT);
}

unsigned long ping(){
  pinMode(ultraSoundSignal, OUTPUT);         // Switch signalpin to output
  digitalWrite(ultraSoundSignal, LOW);       // Send low pulse
  delayMicroseconds(2);                      // Wait for 2 microseconds
  digitalWrite(ultraSoundSignal, HIGH);      // Send high pulse
  delayMicroseconds(5);                      // Wait for 5 microseconds
  digitalWrite(ultraSoundSignal, LOW);       // Holdoff
  pinMode(ultraSoundSignal, INPUT);          // Switch signalpin to input
  digitalWrite(ultraSoundSignal, HIGH);      // Turn on pullup resistor
                                             // please note that pulseIn has a 1sec timeout, which may
                                             // not be desirable. Depending on your sensor specs, you
                                             // can likely bound the time like this -- marcmerlin
                                             // echo = pulseIn(ultraSoundSignal, HIGH, 38000)
  echo = pulseIn(ultraSoundSignal, HIGH);    //Listen for echo
  ultrasoundValue = (echo / 58.138) * .39;   //convert to CM then to inches
  return ultrasoundValue;
}


void loop(){
  int x = 0;
  x = ping();
    Serial.println(x);
    delay(250);                               //delay 1/4 seconds.
}


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




NewPing Library for Arduino (Ultrasonic Sensors)

http://code.google.com/p/arduino-new-ping/


Bessere Bibliothek: NewPing
Arbeitet mit vielen verschiedenen Ultraschallsensor Modelle: HC-SR04, SRF05, SRF06, DYP-ME007, Parallax PING)))

Simple NewPing Example Sketch



NewPing HC-SR04 Ultrasonic Sensors_1a.ino

NewPing.h  fehlt ! ! !


// Titel: NewPing HC-SR04 Ultrasonic Sensors
// Beschreibung: Abstand messen 3cm bis 3m
// Autor: Fritz Prenninger
// Datum: 2015-04-18
// Sketch: NewPing HC-SR04 Ultrasonic Sensors_1a.ino
// Shield: keines
// Controller: Arduino UNO R3
// Version: Arduino 1.0.6
// Tools: COM4

// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567

// ---------------------------------------------------------------------------
// Beispiel NewPing Bibliothek Skizze, die einen Ping macht etwa 20 mal pro Sekunde.
#include <NewPing.h>

#define TRIGGER_PIN  12  // Trigger pin-12
#define ECHO_PIN     11  // Echo pin-11
#define MAX_DISTANCE 200 // Maximaler Abstand wir für Ping (in Zentimetern) möchten 
// Maximale
Sensorabstand wird bei 400 bis 500 cm ausgelegt
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);  // NewPing Einrichtung von Stiften und maximale Entfernung
void setup() {   Serial.begin(115200); // Öffnet den Serial-Monitor mit 115200 Baud }
void loop() {   delay(50); // Warten 50ms zwischen Pings (ca. 20 Pings / sec)
// 29ms
sollte die kürzeste Verzögerung zwischen Pings sein
  unsigned int uS = sonar.ping();     // Ping senden, erhalten Ping-Zeit in Mikrosekunden (us)
  Serial.print("Ping: ");
  Serial.print(uS / US_ROUNDTRIP_CM); // Ping-Zeit zu distanzieren und Druckergebnis zu konvertieren 
// (0 = außerhalb Satz Abstandsbereich, kein Ping-Echo)
  Serial.println("cm"); }

https://code.google.com/p/arduino-new-ping/
https://code.google.com/p/arduino-new-ping/wiki/Simple_NewPing_Example
http://forum.arduino.cc/index.php/topic,106043.0.html






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

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






Comments