|
http://sites.schaltungen.at/sie-fahren-km-h/radarsensor Doppler-Radar-Modul IPM-165 IPM165Wels, am 2018-05-18BITTE nützen Sie doch rechts OBEN das Suchfeld [ ] [ Diese Site durchsuchen]DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I** DIN A4 ausdrucken (Heftrand 15mm / 5mm) siehe http://sites.schaltungen.at/drucker/sites-prenninger
********************************************************I* ~015_b_PrennIng-a_sie.fahren.km.h-radarsensor (xx Seiten)_1a.pdfRadar-Sensor zur Geschwindigkeitsmessung mit ARDUINO Radarsensor 165
RAD165 (= IPM-165 mit Verstärkerschaltung € 27,99 vorhanden)
Radarsensor 165 inkl. Verstärkung (73 dB)24 GHz Low cost CW Radarsensor (Low Cost K-Band Transceiver) inkl. 40-73 dB Verstärkung (regelbar).Bereit zum Anschluss an einen Atmel Microcontroller oder Arduino ADC Eingang. Auswertungsmöglichkeiten: Bewegungen und Geschwindigkeiten. Typische Anwendungsbereiche: Alarmanlagen, Türöffner, Industrielle Applikationen. 
Funktionsprinzip vom Radar Modul
Dieser IMP165 (IMP-165) Doppler Radarsensor ist von Weidmann Elektronik und hat eine regelbare Verstärkung.
Das Modul sendet selbstständig Radarwellen aus und wertet die empfangenen Signale aus.
Wird eine Bewegung erkannt, so fängt das Modul an, Spannungsdifferenzen am analogen Ausgang zu erzeugen.
Je nach Empfindlichkeit sind diese unterschiedlich hoch, weshalb bei der Verwendung der Library die Toleranz in Prozent angegeben werden muss.
Die Grafik stellt eine detektierte Bewegung in Form einer Spannungsdifferenz am analogen Eingang dar.
Das Doppler Radar Modul für Arduino kann Geschwindigkeiten und Bewegungen detektieren.
Da es am Markt sehr viele unterschiedliche Radar Module gibt, kann diese Anleitung und die bereitgestellte Library möglicherweise nicht kompatibel sein.
Das hier gezeigte Modul arbeitet mit 5V und gibt die Radardaten analog zum Arduino weiter.
Diese Radarmodule sind extrem empfindlich, weshalb eine stabile Stromversorgung sehr wichtig ist.
Die 5V USB-Stromversorgung vom Rechner ist nicht besonders sauber, reicht für Testzwecke jedoch aus.
Wenn sich die Empfindlichkeit vom Modul einstellen lässt, so sollte das Potentiometer in das erste Viertel gedreht werden.
// More information at: // https://www.aeq-web.com/arduino-radar-motion-detector/?ref=arduinoide Sketch and Library ORDNER Arduino_Radar_Library AEQ-WEB Arduino Doppler Radar, Dieser InnoSenT AMP165 Doppler Radarsensor 165 ist von Weidmann Elektronik und hat eine regelbare Verstärkung. Das Modul sendet selbstständig Radarwellen aus und wertet die empfangenen Signale aus. Wird eine Bewegung erkannt, so fängt das Modul an, Spannungsdifferenzen am analogen Ausgang zu erzeugen. https://www.aeq-web.com/arduino-radar-motion-detector/ https://www.aeq-web.com/arduino-radar-motion-detector/?ref=arduinoide ********************************************************I* Radarsensor 165
RAD165 (= IPM-165 mit Verstärkerschaltung € 27,99 vorhanden)
Doppler-Radar-Geschwindigkeitsmessung - H-J BerndtH. J. Berndt Homepage von Hans-Joachim BerndtRADAR Geschwindigkeitsmessung mit ARDUINO UNO mit Doppler-Rafar-Sensor IPM-165 http://www.hjberndt.de Geschwindigkeitsmessung mit ARDUINO
Blitzkasten in der Hosentasche Messen Steuern
Radar-Geschwindigkeitsmessung Arduino/Handy in C/Basic Mit dem Smartphone einen eigenen Blitzkasten herstellen: 24 GHz Doppler-Radar misst die Geschwindigkeit und löst ein Blitzfoto aus Mit dem IPM-165 - 24 GHz Mono-CW-Radarsensor bietet InnoSenT GmbH ein interessantes Radar-System an.
Der Sensor arbeitet als Dauerstrichradar (Continous Wave) und hat einen analogen Ausgang, der mit 300 mV angegeben ist.
Das Doppler-Prinzip kommt aus der Wellenlehre und nutzt bei bewegten Gegenständen die Frequenzänderung. Im Straßenverkehr wurde/wird dieses Verfahren bei Geschwindigkeitskontrollen eingesetzt.
Wenn ein Sender eine Welle ausstrahlt und diese, von einem bewegten Gegenstand reflektiert, wieder empfangen wird, entsteht die so genannte Doppler-Frequenz bzw. eine Frequenzdifferenz zwischen Sende- und Empfangsfrequenz.
Diese Frequenz liefert das Modul an seinem Analog-Ausgang. Bei 24 GHz berechnet sich 44 Hz pro 1 km/h.
Um eigene Lötarbeiten zu vermeiden, wurde ein fertiges Modul (links) mit Verstärkerplatine bei weidmann-elektonik.de geordert (rechts das HC-06 Bluetooth-Modul).
Die stilvolle Platine passt sich dem Modul völlig an. Dort im Shop gibt es auch noch weitere 'nützliche' Dinge ...
Hält man die Hand ruhig vor den Sensor, so entsteht kein Signal.
Zieht man sie schneller werdend weg, so entsteht das dargestellte Oszillogramm (blau: Analognignal am Modul 50 mV/Div und das um ca. 40 dB verstärkte Signal am digitalen Kanal) des DSO-Quad.
Die Dopplerfrequenz nimmt sichtbar zu - es ist eine Beschleunigung zu erkennen.
Nach 90 ms ist das Signal zu schwach.
Die erste Schwingung dauert 10 ms, wodurch sich ca. 2,3 km/h errechnen.
Übersicht vom Frequenzzähler zum Blitzkasten Übersicht vom Frequenzzähler zum Blitzkasten Test am Arduino (modifizierter Frequenzzähler) Geschwindigkeitsradar mit LCD-Anzeige Bewegungsmelder in 11 Zeilen Bewegungsmelder via Bluetooth Geschwindigkeitsradar mit Bluetooth Geschwindigkeitsradar mit Smartphone - (Blitzkasten in der Hosentasche) Theoretischer Hintergrund Test am ARDUINO modifizierter Frequenzzähler Da ein Frequenzzähler für den Arduino schon vorhanden war, wird der alte Quelltext noch mal hervor gekramt und etwas modifiziert.
Neu hinzu kommen die beiden Geschwindigkeits-Variablen.
Um ein Ergebnis zu erhalten wird aus 16 Frequenzmessungen der höchste Wert zur Anzeige gebracht.
int v,vmax,pin = 7;void setup() { Serial.begin(9600); pinMode(pin, INPUT);}void loop() {unsigned long T; // Periodendauer in us double f; // Frequenz in MHz char s[20]; // Ausgabestring vmax=0; // Serial.println("ready"); // Trigger; while( digitalRead(pin)); while(!digitalRead(pin)); for(int i=0;i<16;i++) // 16 Messungen (LCD) {T = pulseIn(pin, HIGH) + pulseIn(pin, LOW); f=1/(double)T; // f=1/T v=int((f*1e6)/44.0); // 24 GHz Radar vmax=max(v,vmax); // Schleppzeiger Serial.print(">"); // 16 Punkte (LCD) } sprintf(s,"%3d km/h",vmax); Serial.println(s); // Ausgabe delay(2000); // 2 Sekunden} Im Serial-Monitor erscheint ein "ready", um Messbereitschaft zu signalisieren.
Die Verstärkung war hier so eingestellt, dass das Poti 'gefühlt' 3 Mikrometer vom linken Anschlag stand, also gerade etwas mehr als 40 dB Verstärkung (100fach).
Bei höheren Stellungen löste der folgende 'Digital-Trigger' aus.
Mit while(digitalRead (pin)) wird gewartet, bis der Eingang auf LOW geht.
Im Anschluss folgt die umgekehrte Prozedur, so dass beim ersten Impuls die Messung beginnt.
In 16 Durchläufen wird die Periodendauer gemessen, die Frequenz berechnet und schließlich der Faktor 44 Hz einbezogen, um auf km/h zu kommen.
Der Höchstwert wird ermittelt und gespeichert. Im Serial-Monitor erscheint nach jeder Messung ein '>'.
Wegen des Timeout von pulseIn() tröpfelt die Messung nach einmaligem Trigger auch bei Ruhe langsam durch.
Das Ergebnis wäre dann 0 km/h. Ruckartige Bewegungen können maximal auch schon mal 50 km/h erreichen.
Wäre dass die Geschwindigkeit einer Ohrfeige?
Nach 2 Sekunden ist die Messanlage wieder scharf.
Geschwindigkeitsradar mit LDC-Anzeige Die Ausgabe der Messung über Serial.print an einen PC ist einfach, aber auch unflexibel.
Als autonomes Messgerät reicht da auch erst einmal eine zweizeilige LCD-Anzeige.
Wie beim "Arduino als Zollstock", oder bei der schon oben angesprochenen Variante "Arduino als Zähler".
Der obige Sketch muss an wenigen Stellen etwas angepasst werden.
#include <LiquidCrystal.h>LiquidCrystal lcd(12, 11, 5, 4, 3, 2);int v,vmax,pin = 7;void setup() { lcd.begin(16, 2); lcd.print("Arduino-Radar"); pinMode(pin, INPUT); pinMode(13,OUTPUT);}void loop() {unsigned long T; // Periodendauer in us double f; // Frequenz in MHz char s[20]; // Ausgabe vmax=0; // lcd.setCursor(0, 1);lcd.print("Ready ... "); while( digitalRead(pin)); while(!digitalRead(pin)); for(int i=0;i<16;i++) // 16 Messungen (LCD) {T=pulseIn(pin,HIGH)+pulseIn(pin,LOW); f=1/(double)T; // f=1/T v=int((f*1e6)/44.0); // 24 GHz Radar vmax=max(v,vmax); // Schleppzeiger lcd.setCursor(i, 1);lcd.print(">"); } sprintf(s,"%3d km/h",vmax); lcd.setCursor(0, 0); lcd.print("Gemessen");lcd.print(s); lcd.setCursor(0, 1);lcd.print("================"); delay(2000); // 2 Sekunden} Nach der Initialisierung in Setup() folgt die Anzeige des Projekts, nämlich "Arduino-Radar".
Die eigentliche Messung ist gleich geblieben, nur die Darstellung erfolgt nun so, dass ein "Ready ..."
Bereitschaft ankündigt und nach erfolgter Triggerung in der unteren Zeile jeweils ">" pro Messung angezeigt werden.
Als Ergebnis steht dann der Maximalwert in km/h unterstrichen für 2 Sekunden auf der Anzeige.
Im Anschluss wird dann wieder Mess-bereitschaft angezeigt.
Bewegungsmelder mit sehr wenigen Zeilen Mit einer binären Sketchgröße von nur 1.220 Bytes und nur 11 Zeilen lässt sich mit dem ARDUINO UNO R3 und dem Sensormodul ein Bewegungsmelder realisieren.
Bei einer Unruhe im Sensorbereich (Bewegung) leuchtet die LED an Pin 13 für 4 Sekunden.
Es wird einfach nur auf ein Ereignis in Form eines Impulses gewartet und dann die LED kurz angeschaltet.
Mehr nicht.
#define LED 13#define PIN 7void setup() {pinMode(PIN,INPUT); pinMode(LED,OUTPUT);}void loop() {while(!digitalRead(PIN)); while(digitalRead(PIN)); delay(50); digitalWrite(LED,HIGH); delay(4000);digitalWrite(LED,LOW );// 4 Sekunden} Bewegungsmelder mit Bluetooth Wie schon bei "Steuern mit Bluetooth" gezeigt, eignet sich der Arduino mit HC-Bluetooth-Adapter gut zur Übertragung von seriellen Daten via Bluetooth.
Mit dem HC-06 - wie weiter oben abgebildet - wird der Aufbau nochmals einfacher, wenn die Pegel und die Versorgungsspannung 5 Volt verlangen.
Da das hier benutze BT-Modul sogar mit 9600 Baud voreingestellt ist, kann es einfach in die Pin-Buchse 0 (RX) und 1 (TX) vom Arduino gesteckt werden, da hier die Pinbelegung am HC genau passte (TX in 0 und RX in 1).
Alle Daten werden dann über den Äther geschickt und landen beim entsprechend verbundenen Bluetooth-Gerät.
#define LED 13#define PIN 7void setup() {pinMode(PIN,INPUT); pinMode(LED,OUTPUT); Serial.begin(9600);}void loop() {while(!digitalRead(PIN)); while( digitalRead(PIN)); delay(50); Serial.println("Hier spricht der Arduino."); digitalWrite(LED,HIGH); delay(4000); // 2 Sekunden digitalWrite(LED,LOW);} Das Ergebnis ist hier lediglich die Textzeile "Hier spricht der Arduino".
Die Überprüfung kann am schnellsten mit einem der vielen Bluetooth-Terminal-Programme, die es im Play-Store gibt, erfolgen. Siehe auch Steuern mit Bluetooth.
Geschwindigkeit mit Bluetooth - ARDUINO als Messknecht Werden nun beide Sketche etwas kombiniert, so sollte es möglich sein auch die Geschwindigkeit als Messergebnis zum mobilen Telefon oder Tablet zu übertragen.
Nach den erforderlichen Umbauten, könnte ein Sketch wie folgt aussehen:
int v,vmax,pin = 7;void setup() {Serial.begin(9600); pinMode(pin, INPUT); pinMode(13,OUTPUT);}void loop() {unsigned long T; // Periodendauer in us double f; // Frequenz in MHz char s[40]; // Ausgabe vmax=0; // Maximalwert while(digitalRead(pin)); while(!digitalRead(pin)); digitalWrite(13,HIGH); for(int i=0;i<5;i++) // 5 Messungen {T = pulseIn(pin, HIGH) + pulseIn(pin, LOW); f=1/(double)T; // f=1/T v=int((f*1e6)/44.0); // 24 GHz Radar vmax=max(v,vmax); // Schleppzeiger } // Für das Smartphone via HC06-Bluetooth sprintf(s,"Maximale Geschwindigkeit: %3d km/h",vmax); Serial.println(s); // Ausgabe delay(4000); // 4 Sekunden digitalWrite(13,LOW); } Aus 5 Messungen wird der Maximalwert zum Smartphone oder jedem beliebig per Bluetooth verbundenen Gerät geschickt.
Da kein PC angeschlossen ist, wird für das HC-Modul die normale serielle Verbindung an Pin 0 und Pin 1 benutzt.
Blitzkasten in der Hosentasche - Radar/Arduino/Bluetooth/Smartphone Im eBook "Messen mit dem Smartphone" wird gezeigt, wie mit der eingebauten Kamera des Handys ein klassisches Physik-Experiment recht einfach mit Hilfe von rfo-Basic! durchgeführt werden kann.
Wenn die Geschwindigkeit via Bluetooth vom Radar zum Smartphone gelangt, ist es auch möglich mittels rfo-Basic! die Kamera anzusteuern und ein Foto zu machen - mit Blitz, versteht sich.
Hier der prinzipielle Aufbau:
24 GHz Radar und 2,4 GHz Bluetooth und als Knecht der Arduino.
Die gemessene Geschwindigkeit wird zum Smartphone übertragen und dort löst ein kleines rfo-Basic-Programm die Kamera mit Blitz aus.
Das Bluetooth-Modul und der Radar-Sensor sollten möglichst weit von einander entfernt sein, um Störungen zu vermeiden.
Zumindest die HC-06-Platine ist eher wenig abgeschirmt.
Der Sensor soll in Richtung Straßenrand zeigen, um ein Ergebnis zu erreichen. Es gibt auch kommerzielle Anwendungen für den Offroad-Bereich: Speed-Wedge-Radar. Das rfo-Basic!-Listing ist kurz, da hier einige Dinge in separate Quelltexte ausgelagert wurden, der Ablauf wird dadurch übersichtlicher.
Das HC-06-Modul sollte dem Smartphone ebenfalls schon bekannt sein, so dass mit btopen.bas eine Verbindung hergestellt werden kann.
Nach einer Weile erfolgt die Ausgabe des verbundenen Geräts. Nach 2 Sekunden erscheint im Text-Modus "ready to shoot" und die Bluetooth-Leseroutine wird aufgerufen.
Diese kehrt erst zurück, wenn eine Zeichenfolge mit abschließendem Zeilenvorschub (13) empfangen wurde.
Der Inhalt der Meldung in A$ wird nicht überprüft und in camerashoot.bas weiter verarbeitet.
Die Kamera wird mit Blitz ausgelöst, das Bild dargestellt und die Zeichenkette A$ in das Bild geschrieben.
Das Blitzfoto ist fertig und wird als "image.png" im data-Verzeichnis abgelegt.
Danach wird der Grafikmodus verlassen und die Zeichenkette auch auf den Textbildschirm ausgegeben.
Nach einer halben Sekunde wird der Bluetooth-Status abgefragt und bei fehlender Verbindung geschlossen, falls nicht, ist die Kamera wieder "ready to shoot".
PRINT "Radarblitz-Test mit HC-06/Arduino."PRINT "Doppler-Modul mit 24 GHz HB 2867 an Pin 7,"PRINT "Arduino sendet die Geschwindigkeit"PRINT "mit Serial.println .... via Bluetooth."PRINT "Das Smartphone macht ein Blitzfoto."PRINT "Suche Gerät im Äther..."INCLUDE btopen.basPAUSE 2000CLSDO PRINT "ready to shoot" INCLUDE btread.bas GR.OPEN 255,16,16,16 INCLUDE camerashoot.bas GR.CLOSE PRINT a$ PAUSE 500 BT.STATUS sUNTIL s<>3BT.CLOSEENDONERROR:END Aufgrund der Konstruktion des Verstärkers, liegt das Ruhesignal bei etwa 2,5 Volt.
Bei Störungen gibt es mehr oder weniger große Schwankungen um diese "Nulllinie".
Der bis hier digital ausgebildete Auslösetrigger kann noch optimiert werden - in einer zweiten Anwendung soll diese Methode benutzt werden, um eine Kalibrierung der Messanordnung zu erreichen.
Theoretischer Hintergrund - Doppler-Frequenz
FEHLT alles siehe Quelle
Quelle:
http://www.hjberndt.de/soft/radar/index.html
********************************************************I* Radarfalle - Radarfall 'Experimentelle Kalibrierung' - 24-GHz-Radar-Sensor IPM-165 Radarfalle - Radarfall Referenzmessung und Genauigkeit Klassische Mechanik für Schreibtischtäter. Ergänzung zum eBook: Messen und Steuern mit dem Smartphone 
Um eigene Lötarbeiten zu vermeiden, wurde ein fertiges Modul mit Verstärkerplatine bei weidmann-elektonik.de geordert.
Dort gibt es noch weitere Anwendungen zum Modul...
Der IPM-165 - 24 GHz Mono-CW-Radarsensor wurde bereits hier unter Geschwindigkeitsmessung mit Arduino eingesetzt. Es stand aber bisher die Frage im Raum: Wie genau ist das Messergebnis? Bei der Durchführung erster Messungen wird wohl meist ein von der Seite geführter Schlag mit der flachen Hand ausgeführt, um ein Ergebnis zu erhalten.
Schon bald stellt sich die Frage, wo es eine genaue Geschwindigkeitsreferenz in der Nähe gibt.
Für die obige Handbewegung sind Messtabellen und Referenzwerte nicht verfügbar, soweit bekannt.
Aus diesem Grund muss nach einem anderen Vergleich mit einer definierten Geschwindigkeit gesucht werden.
Ein eigentlich nicht ganz so schwieriger Fall, da so naheliegend. Schon vor einiger Zeit haben sich Menschen mit diesem Problem beschäftigt, allerdings unter anderem Aspekt.
Der Freie Fall aus der Klassischen Mechanik liefert hier die gewünschte Referenz.
Es folgt ein Aufbau für Schreibtischtäter:
Versuchsaufbau für bequeme Schreibtischtäter 
Die Wahl der Brettchenunterlage resultiert aus einer psychotraumatischen Therapie. Es kann natürlich auch andere, nicht mehr benötigte Literatur benutzt werden.
Ein Beispiel zeigt die Abbildung bei den Messergebnissen.
Eine Grapefruit fällt frei aus einer Höhe von 70 cm auf ein Holzbrett.
Da Radar eine elektro-magnetische Welle im GHz-Bereich ist, stellt dünnes, trockenes Holz kein großes Hindernis dar.
Der Sensor ist geschützt unter dem Brett mit zwei Gummiringen fixiert angebracht. Alle Körper fallen im Vakuum gleich schnell, heißt es.
Es liegt hier zwar kein luftleerer Raum vor, trotzdem soll der Auftrieb und der Luftwiderstand der Frucht vernachlässigt werden können.
Der Versuch könnte mit kleinen Eisen-, Blei- oder Stahlkugeln wiederholt werden...
Newton im Wohnzimmer - Fall der Pampelmuse/Apfelsine/Grapefruit Die Klassische Mechanik liefert die Formel der Geschwindigkeit beim 'Freien Fall':  Bei einer Fallhöhe h von 0,7 m und der mittleren Fallbeschleunigung g = 9,81 ms-2 berechnet sich die Geschwindigkeit zu:   Ausgehend von einem ganzzahligen Messergebnis können Werte zwischen 12 und 14 km/h noch im gültigen Bereich liegen.
Hier könnte der Sketch umformuliert werden, um die Geschwindigkeit mit Nachkommastellen und in m/s an zu geben.
Durchführung 
Rechts unten kann am roten Potentiometer die Verstärkung eingestellt werden. Der Sketch und der Aufbau für den Arduino werden etwas modifiziert, um eine bessere Triggerung zu erreichen.
Das Listing ist unten angegeben.
Der praktische Aufbau erfolgt nach gegebener schamatischer Skizze, die Verschaltung entsprechend dem Sketch.
Die Einstellung der Verstärkung bzw. der Empfindlichkeit am Verstärker kann durch kurze Handbewegungen erfolgen.
Die LED am Arduino leuchtet bei Messbereitschaft, also ohne Triggerauslösung.
Das Potentiometer ist so einzustellen, dass im Ruhezustand noch gerade keine Messung ausgelöst wird.
Nun kann die Anordnung positioniert werden und eine Probemessung erfolgen.
Die Frucht wird entweder auf Höhe der Tischkante einfach losgelassen (ohne den Arduino zu treffen) oder sie wird über den Rand gerollt, so dass eine Art schiefer Wurf entsteht.
Auch dabei ist die Fallzeit, sowie die Fallgeschwindigkeit trotz Parabelbahn laut Theorie ja gleich.
Messergebnis - Probemessung und relativer Fehler Eine Grapefruit mit einem Durchmesser von etwa 8 cm liefert mehrfach reproduzierbar eine Anzeige von 12 km/h.
Dem Reiz, auch hinter das Komma zu gucken, kann nicht widerstanden werden!
Nach Änderung des Variablentyps für v und vmax in double und der Korrektur der Berechnungs- und Ausgabezeile v = (f*1e6)/44.0; // 24 GHz Radar Serial.print(vmax,2); Serial.println(" km/h");  erscheint nun ein erster Messwert mit 12,68 km/h mit zwei Nachkommastellen! Dies entspricht einem relativen Fehler von nur 5% bei diesem ersten Ergebnis.
Die Messreihe kann beginnen. So mancher Aufbau mit Haltemagnet und Digitalzähler liefert da schlimmere Ergebnisse.
Vielleicht entsteht so ein neuer Praktikumsversuch an Schulen...
Nach dem Fall der Kastanie aus eigener Feder
- einem Video mit Einzelbild-Auswertung vor einer Steinmauer
- bei dem die Zeit in Bild und der Weg in Stein gemessen wurde, sowie dem Fallversuch wie von Dr. Braak durchgeführt, bei dem mit Laptop und Soundsoftware die Zeit zwischen Schaltergeräusch und Aufprall akustisch bestimmt wird, nun also der Radarfall, bei dem die Messgröße direkt die Geschwindigkeit ist.
Verbesserter Trigger >1000fach besser Als Verstärker ist ein Zweifach-Operationsverstärker verbaut, die einzelnen Stufen sind als invertierender Verstärker ausgelegt, wobei eine Stufe regelbar ist.
Durch einen Spannungsteiler wird das Bezugspotenzial auf die halbe unipolare Betriebsspannung gelegt.
Der Vorteil ist der Verzicht auf negatives Potenzial, der Nachteil scheint zunächst der für Digitaleingänge ungünstige Ruhepegel von 2,5 Volt zu sein. Wird ein Arduino (o.ä) eingesetzt, gilt diese Einschränkung nicht.
Hat der Digitaleingang nur eine Schaltschwelle, so hat der Analogeingang mit 10-Bit-Auflösung 1024 Triggerschwellen.
Aus diesem Grund wird nicht mehr digital, sondern analog ausgelöst.
Wird nun der bisherige Digitaleingang (Pin 7) zusätzlich mit Analogeingang A0 verbunden, ist hoch auflgelöstes Triggern möglich, mit jeweils 512 Stufen oberhalb und unterhalb des Ruhepegels.
Die Triggerschwelle ist im Sketch fest auf den Wert 30 eingestellt. Wird dieser Wert unterschritten, beginnt die Messfolge.
#define TRIGGER_IN A0#define TRIGGER_LEVEL 30#define RADAR_IN 7#define RADAR_OUT 13#define SCANS 8 int trigger; Der Deklarationsteil zeigt die Konstanten und eine Variable für den neuen Trigger.
Der Ausgang RADAR_OUT zeigt die Unruhe am Verstärkerausgang.
Ein PWM-Ausgang (Pin 5) würde ein quasi analoges Signal an einer LED ausgeben.
Hier wird lediglich die eingebaute LED an Pin 13 benutzt.
Die Triggerung in der Hauptschleife sieht nun so aus: ... Serial.println("ready"); // Trigger; do {trigger=analogRead(TRIGGER_IN); analogWrite(RADAR_OUT, map(trigger, 0, 1023, 0, 255)); } while(trigger>TRIGGER_LEVEL); analogWrite(RADAR_OUT,0); ... Die do-while-Schleife wartet, bis die Triggerschwelle unterschritten ist.
Dabei wird der momentane Analogwert vom Verstärker als Arduino-"Analogwert" einer LED an Pin RADAR_OUT zugeführt.
Vor Beginn der Messung wird sie ausgeschaltet.
Der Sketch für die Radarfalle - den Radarfall: /* Radar-Sensor RSM-1650 24 GHz Verstärkung ca. 60 dB Gibt die Geschwindigkeit v mit zwei Nachkommastellen aus, wenn 44 Hz 1 km/h entsprechen. */#define TRIGGER_IN A0#define TRIGGER_LEVEL 30#define RADAR_IN 7#define RADAR_OUT 13#define SCANS 8 int trigger;double v,vmax;void setup() { Serial.begin(9600); pinMode(RADAR_IN,INPUT); pinMode(RADAR_OUT,OUTPUT); pinMode(TRIGGER_IN,INPUT);}void loop() {unsigned long T; // Periodendauer in us double f; // Frequenz in MHz vmax=0; // Serial.println("ready"); // Trigger; do {trigger=analogRead(TRIGGER_IN); analogWrite(RADAR_OUT, map(trigger, 0, 1023, 0, 255)); } while(trigger>TRIGGER_LEVEL); analogWrite(RADAR_OUT,0); for(int i=0;i<SCANS;i++) // 8 Messungen {T = pulseIn(RADAR_IN, HIGH) + pulseIn(RADAR_IN, LOW); f=1/(double)T; // f=1/T v=((f*1e6)/44.0); // 24 GHz Radar vmax=max(v,vmax); // Schleppzeiger Serial.print(">"); // 16 Punkte (LCD) } Serial.print(vmax,2);Serial.println(" km/h"); delay(2000); // 2 Sekunden} Fazit Eine Kalibrierung im Sinne der Definition des Sensors fand hier nicht statt.
Vielmehr wurde mit einem bekannten Wert verglichen, also eine Art Referenzmessung durchgeführt.
Ungenauigkeiten tauchen eher bei der Programmierung oder dem realen mechanischen Aufbau auf.
Die Genauigkeit dieser Anordnung dürfte für viele Fälle hoch genug sein.
Gab es beim Verkehrsradar nicht auch 10% Toleranz?
Theoretischer Hintergrund - Doppler-Frequenz
FEHLT alles siehe Quelle
Quelle: http://www.hjberndt.de/soft/radar/indexfall.html ********************************************************I*
Abstandsmessung mit Ultraschall Copy/Paste
Arduino als Zollstock für Arduino in C Das Prinzip Echolot oder der Aufbau eines Ultraschall-prüfkopfes.
Wie auch immer, es ist extrem einfach mit dem Arduino beeinduckende Ergebnisse zu erziehlen.
Mit drei Drähten und drei Mausklicks entsteht ein Abstands-messgerät mit Ultraschall.
Der Quelltext kommt von der Seite Arduino.cc, ist also fix und fertig.
Arduino als Zollstock Ultraschall-Abstandsmessung mit Arduino Es soll Schulen geben, da ist Abstandsmessung mit Ultraschall Teil des Praktikums im Fach Physiktechnik. Mit Oszilloskop und Frequenzgenerator werden Impulspakete im 40 kHz Bereich erzeugt. Das alles soll den S/E-Kopf der Ultraschallprüfung verdeutlichen.
Für den Arduino wird zufällig ein ähnlicher Aufbau geliefert.
Title: PING))) Ultrasonic Distance Sensor
Product ID: 28015
Preis: $ 29,99
PING))) https://www.parallax.com/ PING))) Ultrasonic Distance Sensor https://www.parallax.com/product/28015 PING))) Ultrasonic Sensor + Mounting Bracket https://www.parallax.com/product/910-28015a PING))) Ultrasonic Sensor + Protector Stand https://www.parallax.com/product/910-28015b Dual Aluminum Stand PING))) Ultrasonic and Sharp IR Sensor Kit https://www.parallax.com/product/725-28915 Die Firma Parallax bietet einen Ultraschall-Sender / -Empfänger mit drei Anschlüssen an. Sender und Empfänger arbeiten ebenfalls mit 40 kHz.
Die Platine stellt das fertige Signal zur Verfügung und kommt somit mit nur drei Anschlüssen aus: Spannung (5V), Masse und eine Signalleitung.
Diese liefert ein abstands-proportionales Zeitsignal in Form einer Rechteckspannung.
Der Aufbau ist extrem schnell erledigt, da auf den Arduino-Seiten fertige Programme bereit stehen. Bild: PING)))-Hardware. Fünf Minuten für den Aufbau Vorausgesetzt Windows ist schon hoch gefahren, das Internet rennt und die Arduino-Software ist gestartet.
Dann könnte das erste Ergebnis auch schon in 30 Sekunden ...
Wirklich einfacher als mit "einem Baukastensystem, bei dem bunte Kunststoff-Klötzchen, Zahnräder, Figuren und andere Kleinteile zusammengesteckt werden!"
Verdrahtung: Drei Drähte Die Spannungsversorgung (5 V) vom Arduino zur Ping-Platine. Die Masse von Masse zu Masse. Die Signalleitung (SIG) zu Pin 7 des Arduino. Fertig. Software: Drei Klicks Die entsprechende Arduino-Seite aufrufen und den Schaltplan kontrollieren bei Bedarf. Den Code kopieren und in den Arduino-Editor einfügen. Kompilieren und Übertragen. Fertig. Das Zwischenergebnis 
Im Serial Monitor kann das Ergebnis betrachtet werden.
Wie im Sketch zu sehen, wird alle 100 ms eine Messung an die serielle Schnittstelle weitergereicht und über den Arduino-Monitor angezeigt.
Falls ein allgemeines Terminal verfügbar ist, kann die Anzeige auch darüber erfolgen, wenn die entsprecheden Parameter (9600 Bd) eingestellt sind.
Hier kam das Hyperterminal von WinXP zum Einsatz.
Nun muss nur noch "in" in " Zoll" umgewandelt werden und ein Leerzeichen vor "cm" ... 
Die Erweiterung 
Ein Zollstock mit PC-Anschluss ist zwar nett, aber nicht sehr praktikabel.
Mit einer LCD-Anzeige und einem Steckernetzteil bzw. einer Batterie wird der Arduinozollstock autark.
Unter http://arduino.cc/en/Tutorial/LiquidCrystal gibt es das "Hallo Welt"-Beispiel und die Anschluss-Belegung, damit die fertige (!) LCD-Bibliothek auch funktioniert.
Hinweise zu den unterstützten Anzeigen findet man ebenfalls dort. Stichwort: Hitachi HD44780-kompatibel.
Falls die Verdrahtung stimmt, sollte das Beispiel laufen und die bekannten zwei Worte darstellen.
Das Ping-Beispiel wird nun mit wenigen Zeilen aus dem LCD-"Hallo Welt"-Beispiel ergänzt.
Im Deklarationsteil:
// include the library code:#include <LiquidCrystal.h>// initialize the library with the numbers of the interface pinsLiquidCrystal lcd(12, 11, 5, 4, 3, 2); In Setup(): lcd.begin(16, 2);lcd.print("Arduinozollstock");
In Loop() vor Delay(100): //LCDlcd.setCursor(0, 1);sprintf(s,"%3d cm",cm);lcd.print(s);sprintf(s," = %2d Zoll",inches);lcd.print(s); Die Funktion sprintf scheint hier nur eine Variable zu berücksichtigen, darum die zweifache lcd.print-Anweisung.
Hier der Sketch, falls obige Links versagen.
Das Ergebnis 
PING))), Arduino-Uno, LCD-Display, Spannungsversorgung: Solarakku für ein autonomes Meßsystem. Quelle: http://www.hjberndt.de/soft/ardping.html ********************************************************I*
Freeware, Open Source Messen, Steuern, Programmieren
CompactDefinition meets Arduino Ein kleiner Sketch im Arduino gaukelt der Universalsoftware Compact ein CompuLab der Firma ak-modulbus vor.
Mit zwei Analogeingängen und 8 Digitalausgängen können jetzt der YT-Schreiber, der XY-Schreiber und der Programminterpreter benutzt werden - , erweitert auch der Bitschreiber (updated).
Arduino als CompuLab (updated) Compact erkennt Arduino Mit einem kleinen Programm, was in Arduinokreisen Sketch genannt wird, gaukelt der Mikrocontroller Arduino einige Funktionen des CompuLab vor, so, dass Compact-Definition ihn als CompuLab erkennt und behandelt. Man hat somit ein USB-CompuLab an einer seriellen Schnittstelle ... Die zwei Onboard-Spannungen des Arduino 5,0V und 3,3V werden angezeigt. Die Möglichkeiten Es werden zwei Analogeingänge (8 Bit-Auflösung) und acht Digitalausgänge unterstützt in diesem Sketch.
Digitaleingaben sind nicht vorgesehen. Analogausgaben kennt CompuLab nicht.
Mit diesen wenigen Möglichkeiten kann man in Compact aber:
- Zwei Analogwerte (A-Eingang und B-Eingang) mit Analogmetern anzeigen. - Zwei Analogwerte in einem Zeitschreiber darstellen und exportieren. - Zwei Analogeingänge in einem XY-Schreiber darstellen und exportieren. - Acht Digitalports Schalten. UND - Programme für den compacteigenen Interpreter verfassen (Ein Lauflicht liegt bei) Der Sketch #define AIN1 60#define AIN2 58#define DIN 211#define DOUT 81//DIGITAL OUT 0 - 7byte Douts[] = {6,7,8,9,10,11,12,13}; //DIGITALPINSbyte Bits[] = {1,2,4,8,16,32,64,128};//BitValuebyte Ains[] = {0,1}; //ANALOGPINSvoid setup(){ Serial.begin(9600); for(int i= 0;i<8;i++)pinMode(Douts[i],OUTPUT); for(int i= 0;i<2;i++)pinMode(Ains[i], INPUT);}void loop(){ int i,val,inbyte ;byte b; val = Serial.available(); //Was da? if (val>0) {inbyte=Serial.read(); //abholen delay(1); switch(inbyte) { case 13 : Serial.write(2);delay(2);break; //ID case DIN : Serial.write(255);break; //Für Compact case AIN1: Serial.write(analogRead(Ains[0])>>2);break; case AIN2: Serial.write(analogRead(Ains[1])>>2);break; case DOUT: b=Serial.read(); //Ausgabebyte holen for(i=0;i<8;i++) digitalWrite(Douts[i],b&Bits[i]?HIGH:LOW); break; default: break; } } delay(5);} Die Benutzung (how to) CompactDefinition 1.75b herunterladen und in ein Verzeichnis entpacken. Den Sketch in den Arduino übertragen Die Ausgänge 6,7,8,9,10,11,12,13 mit Leuchtdioden versehen. Eine Verbindung AnalogIn 0 zu 5 Volt und AnalogIn 1 zu 3,3 Volt als Beispiel. CompactDefinition starten. (Startet erst mit langsam wechselnden Spannungen) Hardware Suchen drücken. (evtl. mit der Strg-Taste) Bei gedrückter Strg-Taste sollte nebenstehende Meldung sichtbar werden.
Wenn alles richtig funktioniert, kann man nun die Leuchtdioden schalten, die Analogspannungen registrieren oder das Lauflicht laden (Rechte Maustaste im Programmfenster).
Eine ausführliche Beschreibung zu CompactDefinition findet man hier.
Erweiterung Betrachtet man die Anschlussmöglichkeiten des Arduino, so kommt man auf die Zahl 20.
Zwei der Digitalleitungen werden für die serielle Kommunikation benutzt und sollten darum unbeschaltet bleiben.
Es bleiben 18 I/O-Leitungen.
Das CompuLab hat 2 Analogeingänge, 8 Digitaleingänge und 8 Digitalausgänge. In der Summe 18 I/O-Leitungen.
Das kann kein Zufall sein.
Mit einem weiteren Sketch könnte die Emulation perfektioniert werden.
Die Dummyfunktion DIN aus dem ersten Sketch wird zum Leben erweckt (mit DIN prüft Compact, ob die Hardware noch lebt. Darum zunächst die Rückgabe von konstant 255).
Die Pins werden etwas umgeordnet und 4 Analogeingänge werden als Digital-Anschlüsse benutzt, wie schon bei der Rheinturmuhr.
Also an die Arbeit ... a//COMMANDS CLAB#define AIN1 60#define AIN2 58#define DIN 211#define DOUT 81//DIGITAL OUT PINS 0 - 7 CLABbyte Douts[] = {10,11,12,13, 16,17,18,19};//DIGITAL IN PINS 0 - 7 CLABbyte Dins[] = { 2, 3, 4, 5, 6, 7, 8, 9}; //ANALOG IN PINS A - B CLABbyte Ains[] = {0,1}; //BitValuesbyte Bits[] = {1,2,4,8,16,32,64,128};void setup(){ Serial.begin(9600); //Special CLAB for(int i= 0;i<8;i++)pinMode(Douts[i],OUTPUT); for(int i= 0;i<2;i++)pinMode(Ains [i],INPUT); for(int i= 0;i<8;i++) {pinMode(Dins [i],INPUT); //OPEN IS HIGH digitalWrite(Dins[i],HIGH); //WITH PULLUP }}void loop(){ int i, val, inbyte; byte b; val = Serial.available(); //Was da? if (val>0) {inbyte=Serial.read(); //abholen delay(5); switch(inbyte) { case 13 : //CLAB ID nur bei Compact 1.75! Serial.write(2);delay(2);break; //ID case DIN : for(i=0,b=0;i<8;i++) //PINS to BYTE b+= (digitalRead(Dins[i])==HIGH?Bits[i]:0); Serial.write(b);break; case AIN1: Serial.write(analogRead(Ains[0])>>2);break; case AIN2: Serial.write(analogRead(Ains[1])>>2);break; case DOUT: b=Serial.read(); //Ausgabebyte holen for(i=0;i<8;i++) digitalWrite(Douts[i],b&Bits[i]?HIGH:LOW); break; default: break; } } delay(10);} 
Die Arduino-Pins 0, 1 wurden ausgespart wegen der seriellen Kommunikation.
Pin 13 bleibt Ausgang, da er auf dem Board schon eine LED speist.
Die Pullup-Widerstände sorgen bei den Digitaleingängen dafür, dass offene Pins als HIGH erscheinen.
Somit ergeben die Eingänge unbeschaltet das Byte 255, wie schon in der Version 1.
Jetzt kann schließlich der Bitschreiber benutzt werden, der die acht Digitaleingänge als Datenlogger darstellt. Der Quelltext als gepackte Datei (zip) kann hier geladen werden. Jetzt fehlen noch die Schraubklemmen und das Gehäuse ... Quelle: http://www.hjberndt.de/soft/ardcompact.html DIN A4 ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:[email protected]ENDE |