// 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.comint signal=8;   // verbinde Parallax Ping))) Signalstift in digitale pin-8 ARDUINOint 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}

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/

Sketch

// 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/Pingconst int pingPin = 7; // Diese Konstante wird sich nicht ändern, es ist der Pin-7 des Sensors Anschlussesvoid 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;}

Ultraschallsensoren für Kollisionvermeidung

4-Pin Ultraschall- Modul HC-SR04 Abstand Messung

// 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-13void 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}

Arduino mit Abstandssensor HY-SRF05

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

// 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 Ausgangint rot = 8;       // LEDrot pin-8int gelb = 9;      // LEDgelb pin-9int gruen = 10;    // LEDgrün pin-10void 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  }}

Ultraschallsensor (SRF02)

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.

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.

SRF02 Ultrasonic sensor (SKU:SEN0005)

Diy Arduino Radar

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

SRFxx Sonic Range Finder Reader

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/

1. SDA - Analog pin 4
2.  
3. SCL - Analog pin 5

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-7int 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-12int 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ßenvoid 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-7int echo=6;         // Echo ist pin-6int 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ßenvoid 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

LichtschrankemittelsReflexoptokoppler CNY70 (kurze Distanz)

Lichtschrankemittels TEMIC K153P (kurze Distanz)

Diese Lichtschranke besteht auseiner Infrarot-Sendediode (hellblau;Wellenlänge: 950 nm) und einem Fototransistor alsEmpfänger (schwarz). Der große Vorteil diesesPärchens ist der Preis: bei Pollinkosten 10 Paare weniger als1 €! Die Inbetriebnahme der TemicK153P ist einfach:

Funktionsweise:

Die Infrarotdiode sendet einLicht, das für unser Auge nichtsichtbar ist, aus. Solange kein Licht auf die Basis des Fototransistorstrifft, 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 Fototranistorist empfindlich für Streulicht. Somit sind nur sehr begrenzteReichweiten möglich.

Aufgabe:

1. Experimentiere mitverschiedenen Vorwiderständen (Poti verwenden) fürdenFototransistor, um zu testen,welcheReichweite möglich ist.

GabellichtschrankeTCST2000 (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); 
}

AbstandssensorSHARP GP2Y0A02YK0F(mittlere Distanz)

Der SharpGP2Y0A02YK0F ist z.B. bei Segorgünstig erhältlich und deckt eine Reichweite von 20cm - 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. Verbindungskabelmitbestellen.

Der große Vorteilgegenüber den oben verwendeten Lichtschranken ist, dass beidiesem Modell das gesendete Infrarotlicht moduliert wird, d.h. es ist nichtstöranfällig für Streustrahlung. Verwendetwerden solcheSensoren z.B. bei Urinalen, in der Robotik, ...

Der Ausgangdes Sensors liefert ein Potenzial zwischen 0 V und 5 V und wird aneinen analogen Port angeschlossen. Am analogen Port haben wir eine 10bit Auflösung, d.h. (2¹⁰=1024verschiedene) Messwerte von 0 bis 1023 sind möglich. Nun mussmanden Messwert noch in die Entfernung zurückrechnen. Dazu musskannman die Kurve im Datenblatt durch eine Hyperbel annähern (nochbesser wäre evtl. eine Exponentialfunktion). Bei mir klappt esganz gut mit folgender Formel:

Wichtig:die Zahlen 10650und -15sollten dem Sensorangepasstwerden, d.h. man stellt ein Hinderniss in 50 cm und 100 cm Entfernungund ändert die Zahl so lange, bis man einebestmöglicheÜbereinstimmung hat. Klar sollte sein, dass der Sensor nur indenvorgesehenen Distanzenein gutes Messergebnis liefert. Möchte man dennoch kleinereEntfernungen damit messen, so müsste man die Abstandsformeländern oder besser einen für diesen MessbereichausgelegtenSensor verwenden.

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

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

Warnung: WirdderPING-Sensor versehentlich mit 9 V verbunden geht er kaputt. Zu erkennenist 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);
}

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

Deutlich günstiger alsder PING-Sensor von Parallax ist der HC-SR04von CytronTechnologies. Erbenötigt ein 10 µslanges Triggersignal, woraufhin er acht 40 kHz Impulse aussendet undmisst, wie lange es bis zum Eintreffen des Echos benötigt (150µS bis 25.000 µs). Bei fehlendem Echo werden 38.000µszurückgemeldet. Diese Zeit wird über den Echo-Pinausgegeben und zwar in Form eines Impulses, dessen Weite gerade derSignallaufzeit (in µs und für hin &zurück)entspricht. DieEntfernung (in cm) berechnet sich aus der Signallaufzeit inµs durch:

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 hatden 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-7int echo=6;                            // das Wort echo steht für pin-6long 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

// 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 Arduinovoid 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}

https://github.com/JRodrigoTech/Ultrasonic-HC-SR04/tree/master/Ultrasonic

Cytron Technologies USER MANUAL v1.0 (Mai 2013) HC-SR04 Ultrasonic Sensor

Arduino HC-SR04 (Ultrasonic Sensor)

// 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-8long 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]

// 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 3int 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);}

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 6Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_PIXEL, DATA_PIN, NEO_GRB + NEO_KHZ800);#define trigPin 10#define echoPin 11#define led 13void 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 3int 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// 123456789012345678901234567890123456789012345678901234567890123456789012345678901234567int echoPin=6;int trigPin=7;             //set up ultrasound pins on HC-SR04int led = 13;              //assign LED pinint threshold = 25;//assign threshold distancevoid 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 10void 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-SR04int led = 13;           //assign LED pinint threshold = 10;int note=60;                           //assign threshold distancevoid 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