RADAR

http://sites.prenninger.com/arduino-uno-r3/radar

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2019-04-25

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

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   siehe
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-radar (xx Seiten)_1a.pdf




Download the Arduino IDE
ARDUINO 1.8.9
https://www.arduino.cc/en/Main/Software



Geschwindigkeit messen mit Arduino

Geschwindigkeitsmessung - Arduino

Doppler-Radar-Geschwindigkeitsmessung



Blitzkasten in der Hosentasche - Doppler-Radar-Sensor IPM-165

Geschwindigkeitsmessung mit ARDUINO UNO
Ergänzung zum eBook: Messen und Steuern mit dem Smartphone


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 ...

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.



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

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 sechzehn 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 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 7

void 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 7

void 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.



Das rfo-Basic!-Listing ist kurz, da hier einige Dinge in separate Quelltexte ausgelagert wurden, der Ablauf wird dadurch übersichtlicher.
Wie in [1] und [2] beschrieben, sollte vor dem Start Bluetooth schon aktiviert sein.
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.bas
PAUSE 2000
CLS
DO
 PRINT "ready to shoot"
 INCLUDE btread.bas
 GR.OPEN 255,16,16,16
 INCLUDE camerashoot.bas
 GR.CLOSE
 PRINT a$
 PAUSE 500
 BT.STATUS s
UNTIL s<>3
BT.CLOSE
END

ONERROR:
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.
Hier jedoch erst noch die Theorie zur Praxis:



Theoretischer Hintergrund Doppler-Frequenz
Zunächst der Fall, dass eine stehende Quelle (Sender) sein Signal mit der Sendefrequenz konzentrisch abstrahlt.
Eine Welle bewegt sich dann mit der Geschwindigkeit c vom Sender weg in Richtung Empfänger.
Der Empfänger bewegt sich mit der Geschwindigkeit v auf die Quelle zu.
Die Wellenlänge bleibt konstant, es gibt also nur eine Änderung von Frequenz und Geschwindigkeit.



Entgegengesetzte Geschwindigkeiten addieren sich bei Annäherung zur Relativ-geschwindigkeit: .

Der Empfänger nimmt die erhöhte Empfangsfrequenz fE war, da pro Zeiteinheit mehr Wellen empfangen werden als bei Stillstand.
Mit der Grundgleichung der Wellenlehre und deren verschiedenen Umstellungen



wird die Gleichung für die Empfangsfrequenz gefunden.

und

Nach dem Ausklammern der Sendefrequenz ergibt das:



Dabei gilt (+) bei Annäherung und (-) bei Entfernung.

Der umgekehrte Fall liegt vor, wenn die Quelle sich bewegt und der Empfänger ruht.
Dann ist von außen betrachtet kein konzentrisches Wellenbild zu erkennen, da der Sender jeweils von einem anderen Ort sendet.




Die Wellenlänge verkürzt sich bei Annäherung zu lambda’.
Während einer Schwingungsperiode T0 bewegt sich der Sender mit der Geschwindigkeit v um delta x:



Damit berechnet sich die veränderte Wellenlänge zu:



Für die Frequenz gilt dann .

Somit ist die Gleichung für die wahrgenommene Frequenz einer bewegten Quelle:



Dabei gilt (-) bei Annäherung und (+) bei Entfernung.

Bei Radar-Messungen nach dem CW-Prinzip sendet der Sender ununterbrochen und empfängt eine Differenzfrequenz, auch Dopplerfrequenz genannt.
Der ruhende Beobachter am Straßenrand sendet mit f0 und ein sich bewegender Gegenstand empfängt die veränderte Frequenz, die er reflektiert und als Frequenz fR ans bewegte Quelle ausstrahlt.
Der ruhende Beobachter empfängt nun die Frequenz fQ, wobei die Sendefrequenz des bewegten Gegenstandes fR ist.

Empfangsfrequenz des bewegten Gegenstandes:

Empfangsfrequenz des ruhenden Beobachters:

Die Differenz zwischen f0 und fQ bei Entfernung ist in diesem Fall also die Doppler-Frequenz:





Mit 24 GHz und 1 km/h bzw. 0,277 m/s berechnet sich die Doppler-Frequenz zu:



Referenzmessung mit Radar-Sensor




Quelle:
vhttp://www.hjberndt.de/soft/radar/index.html






Arduino Geschwindigkeitsmessung

Es geht um einen Geschwindigkeitsmessung mittels zwei Lichtschranken im bekannten Abstand.

Die Zeit wird mithilfe von millis() bestimmt und jeweils auf dem seriellen Monitor ausgegeben.
Der Abstand (abstandmm) wird durch die Differenz (dauerms) geteilt.
Damit soll dann die Millimeter pro Millisekunde (Geschwindigkeit) bestimmt werden.
Soweit so gut, doch leider wird bei der Geschwindigkeit auf dem Seriellen Monitor immer 0,00 ausgegeben.
Woran kann das liegen?

Ist der Variablentyp (float) falsch um Kommazahlen zu speichern?

const int empfPinvorne = 2;     // Pin des Empfängers 1
const int empfPinhinten = 3;    // Pin des Empfängers 2



int signalvorne = 0;
int signalhinten = 0;

int messunggestartet = 0;

unsigned long start = 0;
unsigned long ende = 0;

unsigned long dauerms = 0;       // Dauer in Millisekunden
unsigned long abstandmm = 36;    // Abstand in mm der Lichtschranken <-----*************ZUM ÄNDERN**********

float geschwindigkeit = 0.0;




void setup()
{  
  pinMode(empfPinvorne, INPUT);      // Pin des Senders als Eingang 1
  pinMode(empfPinhinten, INPUT);     // Pin des Senders als Eingang 2
  Serial.begin(9600);
  

}


void loop()
{
  signalvorne = digitalRead(empfPinvorne);
  signalhinten = digitalRead(empfPinhinten);

  
  if((signalvorne == HIGH) && (messunggestartet == 0))
  {

    Serial.println("MESSUNG_START bei");
    messunggestartet = 1;
    start = millis();
    Serial.println(start);
    
  }  

    if((signalhinten == HIGH) && (messunggestartet == 1))
  {

    Serial.println("MESSUNG_ENDE bei");
    messunggestartet = 0;
    ende = millis();
    Serial.println(ende);

  
    dauerms = ende - start;
    Serial.println("Differenz(dauerms)=");
    Serial.println(dauerms);

    Serial.println("Abstand(abstandmm)=");
    Serial.println(abstandmm);

    
                                           // geschwindigkeit = abstandmm / dauerms; 
    geschwindigkeit = (float)abstandmm / (float)dauerms;


    Serial.println("Millimeter pro Millisekunde = ");
    Serial.println(geschwindigkeit);
    
    
  }  

  }



Ausgabe am Seriellen Monitor
MESSUNG_START bei
3382
MESSUNG_ENDE bei
4875
Differenz(dauerms)=
1493
Abstand(abstandmm)=
36
Millimeter pro Millisekunde =
0.00


300_d_ARDUINO-x_Automatische Messwerterfassung mit dem ARDUINO UNO  (Mikrocontroller)_1a.pdf






Geschwindigkeitsmessung mit Reflexions-Lichtschranken

Drehzahl mit einem Arduino messen.

Mit Gabellichtschranke EE-SX1041 und Rasterscheibe

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif
U8G2_SSD1306_128X64_NONAME_F_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);

byte DZM_InputPin = 2;
volatile unsigned long RPM_T2, RPM_Count;
unsigned long RPM , RPM_T1;

void setup() {
  u8g2.begin();
  pinMode(DZM_InputPin, INPUT_PULLUP);
  RPM_T1 = 0;
  RPM_T2 = 0;
  RPM_Count = 0;

  attachInterrupt(0, RPM_Meter, FALLING);    // Interrupt0 wird bei fallender Flanke auf Pin2

}

void loop() {
  char RPMStr[5];
  u8g2.clearBuffer();         // löschen des Interen Speicher
  u8g2.setFont(u8g2_font_ncenB14_tr); // auswahl der Schriftart
  if (RPM_T2 > RPM_T1) {
    RPM = (unsigned)(long)(60000 * RPM_Count / (RPM_T2 - RPM_T1));
    RPM_T1 = RPM_T2;
    RPM_Count = 0;
  }
  else {
    RPM = 0;
  }
  sprintf(RPMStr, "%4u", RPM);

  u8g2.drawStr(0, 20, RPMStr); 
  u8g2.sendBuffer();
}

void RPM_Meter () {

  RPM_Count++;
  RPM_T2 = millis();

}


Quelle:
https://arduino-projekte.info/drehzahlmesser/





Geschwindigkeitsmessung mit dem Arduino & TLE4905L



Schaltbild und Hall-Sensor Blockschaltbild des Magnetfeld-Sensors TLE4905L

Im Versuch simuliere ich die Drehzahl eines Fahrrades und die eines Sportwagens und berechne aus der Drehzahl und dem Reifenumfang die Geschwindigkeit in km/h.
Die Messwerte werden auf einer LCD-Anzeige ausgegeben und das Ausgangssignal des Magnetfeldsensors auf dem Oszilloskop dargestellt.
Der Schaltplan und das Programm beschreibe ich im Video.
Übrigens ein interessantes Projekt für Arbeitsgemeinschaften in der Schule, wo die Schaltung an einem Fahrrad getestet werden könnte. Hinweis:
Die wire.h -Bibliothek wird für das Programm nicht gebraucht!
Zusätzliches Video: Hallsonde(vereinfacht)

Torzeit 1sec
Torzeit 5sec

Lüfter  42 U/sec  = 42Hz  = 336,3 km/h


Programm zur Bestimmung der Geschwindigkeit


Quelle:
A. Wendt
https://www.youtube.com/watch?v=oT7__vTji7o




Durchfluss-Sensor mit Arduino u. LCD-Anzeige


Torzeit 1 Sekunde
10 Impulse / Sekunde sind 0,241 Liter / min = 14,4 Liter / Stunde

Durchfluss-Sensoren werden in vielen Bereichen der Industrie genutzt.
Im Video erfahrt ihr, wie die Rechteckimpulse des Flowmeters vom Arduino gemessen und in l/min bzw. in l/h umgerechnet werden.
Mit einer Tauchpumpe werden verschiedene Durchflussmengen eingestellt, gemessen und u.a. die Signale des Flowmeters auf dem Oszilloskop dargestellt.



Quelle:
A. Wendt
https://www.youtube.com/watch?v=LcmfUzS_1CU







die Geschwindigkeit der Kugel beim Kegeln ermitteln.
Der Durchmesser der Kugel ist dabei bekannt (16 cm), was dazu führt, dass man nur eine Lichtschranke benötigt.

Lichtschranke.ino


#define PHOTO_TRANSISTOR  A0 // A0 als Eingang für den Photo-Transistor

unsigned int AnalogVal = 0; // Sensordaten speichern
unsigned int TresholdVal = 700; // Analogwert für High/Low-Übergang
byte BowlDiameter = 16; // Durchmesser der Kegelkugel (in cm)
unsigned long CurrentMicros = 0;  // Microsekunden-Zwischenspeicher
unsigned long Darktime = 0; // Lichtschranken-Unterbrechungszeit (Mikrosekunden)
float Speed = 0; // Geschwindigkeit (km/h)

void setup() {
  pinMode(PHOTO_TRANSISTOR, INPUT); // A0 auf Eingang schalten
  Serial.begin(9600); // Serielle Kommunikation zum PC mit 9600 bps
  Serial.println("Geschwindigkeitsmessung aktiv!");
}

void loop() {
  // warten, bis der Photo-Transistor in den Sperrzustand geht (Lichtschranke wird unterbrochen)
  do {
    AnalogVal = analogRead(PHOTO_TRANSISTOR);
  } while (AnalogVal < TresholdVal);
 
  CurrentMicros = micros(); // aktuellen micros-Wert speichern

  // warten, bis der Photo-Transistor wieder durchschaltet (Lichtschranke nicht unterbrochen)
  do {
    AnalogVal = analogRead(PHOTO_TRANSISTOR);
  } while (AnalogVal > TresholdVal);
 
  Darktime = micros() - CurrentMicros; // die Differenz zum gespeicherten Wert ist die Dunkelzeit
 
  Serial.print("Dunkelzeit: ");
  Serial.print(Darktime);
  Serial.println(" Mikrosekunden");
 
  Speed = BowlDiameter / float(Darktime) * 36000; // umrechnen in km/h
 
  Serial.print("Geschwindigkeit: ");
  Serial.print(Speed);
  Serial.println(" km/h");
}

Lichtschranke.ino


#define PHOTO_TRANSISTOR  A0 // A0 als Eingang für den Photo-Transistor

unsigned int AnalogVal = 0; // Sensordaten speichern
unsigned int TresholdVal = 700; // Analogwert für High/Low-Übergang
byte BowlDiameter = 16; // Durchmesser der Kegelkugel (in cm)
unsigned long CurrentMicros = 0;  // Microsekunden-Zwischenspeicher
unsigned long Darktime = 0; // Lichtschranken-Unterbrechungszeit (Mikrosekunden)
float Speed = 0; // Geschwindigkeit (km/h)

void setup() {
  pinMode(PHOTO_TRANSISTOR, INPUT); // A0 auf Eingang schalten
  Serial.begin(9600); // Serielle Kommunikation zum PC mit 9600 bps
  Serial.println("Geschwindigkeitsmessung aktiv!");
}

void loop() {
  // warten, bis der Photo-Transistor in den Sperrzustand geht (Lichtschranke wird unterbrochen)
  do {
    AnalogVal = analogRead(PHOTO_TRANSISTOR);
  } while (AnalogVal < TresholdVal);
 
  CurrentMicros = micros(); // aktuellen micros-Wert speichern

  // warten, bis der Photo-Transistor wieder durchschaltet (Lichtschranke nicht unterbrochen)
  do {
    AnalogVal = analogRead(PHOTO_TRANSISTOR);
  } while (AnalogVal > TresholdVal);
 
  Darktime = micros() - CurrentMicros; // die Differenz zum gespeicherten Wert ist die Dunkelzeit
 
  Serial.print("Dunkelzeit: ");
  Serial.print(Darktime);
  Serial.println(" Mikrosekunden");
 
  Speed = BowlDiameter / float(Darktime) * 36000; // umrechnen in km/h
 
  Serial.print("Geschwindigkeit: ");
  Serial.print(Speed);
  Serial.println(" km/h");
}












Comments