Arduino FFT für Radarsensor

Hallo zusammen,

ich hab da so eine frage.

Was bedeutete FFT?
Wie funktioniert es dass ich ein signal von einem Radar sensor Rad165 so verwende dass ich KM/H von Fahrzeugen messen kann?

Geht das überhaupt mit meinen Arduinos? (zur auswahl stehen nano, uno, mega)

Ich habe mir zwar die seite von herrn HJBernd dazu angeschaut aber da komm ich so ja nicht weiter.
Weil dieser anscheinend einfach nur Pulse zählt....

Nachdem ich mich an weidmann elektronik gewendet habe habe ich als antwort bekommen das geht so nicht sondern ich muss FFT Rechnen. Oder ein ganzes Board von diesem kaufen das aber 90€ kostet. Das möchte ich eigentlich nicht also muss es irgendwie möglich sein das signal in FFT zu rechnen und das ergebniss dann auf meinen LCD zu zeigen.

Kann mir das bitte jemand erklären oder mir eine erklärung auf deutsch dafür nennen?
Ich habe ehrlich gesagt probleme so technische sachen auf englisch zu verstehen :see_no_evil:

Zur erklärung:

Ich habe einen Gimball für meine DSLR gebaut. Ferngesteuert über IR, mit lichtschranke zur foto auslösung usw.
Jetzt wolte ich zusätzlich die geschwindigkeit der vorbei fahrenden Fahrzeuge messen.

Ja die geschwindigkeit ist ein problem da anscheinend nur max bis 100km/h vernünftig gemessen wird. Aber das solte eig eher weniger ein problem sein....

Und also zusatz info:
Das ganze wird natürlich nicht im Normalen Straßenverkehr eingesetzt. Sondern Hauptsächlich bei Rallyes und auf einem eigenen verkehrsübungsplatz.

grüße

Georg

Sorry, aber wir sind hier nicht in einer Rateshow, sondern in einem Arduino-Forum.
Oder warum schreibst du so in Rätseln.

Nicht jeder kennt die von dir genutzten Begriffe.
Und wer ist HJBernd ?

Und bei FFT (radar fft algorithms) könnte dir Google helfen.

Wer sagt das?
Datenblatt: https://shop.weidmann-elektronik.de/media/files_public/3903faeb3094cc5368bf63413827f490/Radarsensor165.pdf

Da steht schon 200 Km/h.

Na hast Du doch gelesen:

http://www.hjberndt.de/
(kein https)

naja weidmann in einem Tut...
"Erwarten Sie aber von diesem Board nicht zu viel. Hohe Geschwindigkeiten über 100 km/h bzw. Gewehrkugeln werden Sie damit nicht messen können. Theoretisch kann das Board Geschwindigkeiten bis 200 km/h messen."

Das theoretische hat mich da stutzig gemacht.

naja ehrlich gesagt so ein rechenkünstler bin ich halt jetzt nicht wirklich... Für mich sieht die formel irgendwie chienesisch aus .....
Is halt nicht uri :rofl:

Dankeschön!

was ist rätselhaft? Meinst du damit das HJBernd?

lg

Georg

Z.B.: Rad165, HJBernd, Gimball, DSLR,
Nicht jeder kann etwas mit den Begriffen anfangen.
Da ist es einfach wichtig, eine bessere Beschreibung und Links zu posten.

Dann haben alle eine Chance dir zu helfen.
Wer Hilfe will, muss auch gute Informationen liefern.

Sorry ja du hast natürlich recht :see_no_evil: wenn man die begriffe noch nie gehört hat ist es wirklich schwierig!

RAD165
Das ist der Radarsensor
https://shop.weidmann-elektronik.de/index.php?page=product&info=8

HJBernd
Das ist irgendjemand der eine webseite mit ein paar erklärungen und anleitungen hat.
http://www.hjberndt.de/soft/radar/index.html

Gimball
Ein Gimball ist ein "Gerät" auf dem eine kamera montiert ist und sich Motorgesteuert bewegt:
Das auf dem Foto ist meiner. Er ist noch nicht fertig! Daher schaut es da vorne noch ein wenig sehr wild aus :rofl:

Und so sieht er eigentlich gedruckt aus.

DSLR
Ist eine Spiegelreflexkamera.

Ich habe ein beispiel mit einem mikrofon gefunden. Aber ich bin ganz erhlich ich verstehe diesen code absolut rein gar nicht!
ich finde mich da nicht mehr zurecht!
Ich weiß nicht mal wo ich sehe an welchen pin das mikrofon wäre... Und
Das überfordert mich absolut!

/*
//Example data:
int data[64]={14, 30, 35, 34, 34, 40, 46, 45, 30, 4,  -26,  -48,  -55,  -49,  -37,
-28,  -24,  -22,  -13,  6,  32, 55, 65, 57, 38, 17, 1,  -6, -11,  -19,  -34, 
-51,  -61,  -56,  -35,  -7, 18, 32, 35, 34, 35, 41, 46, 43, 26, -2, -31,  -50,
-55,  -47,  -35,  -27,  -24,  -21,  -10,  11, 37, 58, 64, 55, 34, 13, -1, -7};
*/


//---------------------------------------------------------------------------//
byte sine_data [91]=
 {
0,  
4,    9,    13,   18,   22,   27,   31,   35,   40,   44, 
49,   53,   57,   62,   66,   70,   75,   79,   83,   87, 
91,   96,   100,  104,  108,  112,  116,  120,  124,  127,  
131,  135,  139,  143,  146,  150,  153,  157,  160,  164,  
167,  171,  174,  177,  180,  183,  186,  189,  192,  195,       //Paste this at top of program
198,  201,  204,  206,  209,  211,  214,  216,  219,  221,  
223,  225,  227,  229,  231,  233,  235,  236,  238,  240,  
241,  243,  244,  245,  246,  247,  248,  249,  250,  251,  
252,  253,  253,  254,  254,  254,  255,  255,  255,  255
  };
float f_peaks[5]; // top 5 frequencies peaks in descending order
//---------------------------------------------------------------------------//


void setup() 
        {
        Serial.begin(250000);           
        }

        
void loop() {

/*
//example
FFT(data,64,100);        //to get top five value of frequencies of X having 64 sample at 100Hz sampling
Serial.println(f_peaks[0]);
Serial.println(f_peaks[1]);
delay(99999);
*/


/* 
after ruing above FFT(), frequencies available at f_peaks[0],f_peaks[1],f_peaks[2],f_peaks[3],f_peaks[4],
*/           
            }



//-----------------------------FFT Function----------------------------------------------//

float FFT(int in[],int N,float Frequency)
{
/*
Code to perform FFT on arduino,
setup:
paste sine_data [91] at top of program [global variable], paste FFT function at end of program
Term:
1. in[]     : Data array, 
2. N        : Number of sample (recommended sample size 2,4,8,16,32,64,128...)
3. Frequency: sampling frequency required as input (Hz)

If sample size is not in power of 2 it will be clipped to lower side of number. 
i.e, for 150 number of samples, code will consider first 128 sample, remaining sample  will be omitted.
For Arduino nano, FFT of more than 128 sample not possible due to mamory limitation (64 recomended)
For higher Number of sample may arise Mamory related issue,
Code by ABHILASH
Contact: abhilashpatel121@gmail.com 
Documentation:https://www.instructables.com/member/abhilash_patel/instructables/
2/3/2021: change data type of N from float to int for >=256 samples
*/

unsigned int data[13]={1,2,4,8,16,32,64,128,256,512,1024,2048};
int a,c1,f,o,x;
a=N;  
                                 
      for(int i=0;i<12;i++)                 //calculating the levels
         { if(data[i]<=a){o=i;} }
      
int in_ps[data[o]]={};     //input for sequencing
float out_r[data[o]]={};   //real part of transform
float out_im[data[o]]={};  //imaginory part of transform
           
x=0;  
      for(int b=0;b<o;b++)                     // bit reversal
         {
          c1=data[b];
          f=data[o]/(c1+c1);
                for(int j=0;j<c1;j++)
                    { 
                     x=x+1;
                     in_ps[x]=in_ps[j]+f;
                    }
         }

 
      for(int i=0;i<data[o];i++)            // update input array as per bit reverse order
         {
          if(in_ps[i]<a)
          {out_r[i]=in[in_ps[i]];}
          if(in_ps[i]>a)
          {out_r[i]=in[in_ps[i]-a];}      
         }


int i10,i11,n1;
float e,c,s,tr,ti;

    for(int i=0;i<o;i++)                                    //fft
    {
     i10=data[i];              // overall values of sine/cosine  :
     i11=data[o]/data[i+1];    // loop with similar sine cosine:
     e=360/data[i+1];
     e=0-e;
     n1=0;

          for(int j=0;j<i10;j++)
          {
          c=cosine(e*j);
          s=sine(e*j);    
          n1=j;
          
                for(int k=0;k<i11;k++)
                 {
                 tr=c*out_r[i10+n1]-s*out_im[i10+n1];
                 ti=s*out_r[i10+n1]+c*out_im[i10+n1];
          
                 out_r[n1+i10]=out_r[n1]-tr;
                 out_r[n1]=out_r[n1]+tr;
          
                 out_im[n1+i10]=out_im[n1]-ti;
                 out_im[n1]=out_im[n1]+ti;          
          
                 n1=n1+i10+i10;
                  }       
             }
     }

/*
for(int i=0;i<data[o];i++)
{
Serial.print(out_r[i]);
Serial.print("\t");                                     // un comment to print RAW o/p    
Serial.print(out_im[i]); Serial.println("i");      
}
*/


//---> here onward out_r contains amplitude and our_in conntains frequency (Hz)
    for(int i=0;i<data[o-1];i++)               // getting amplitude from compex number
        {
         out_r[i]=sqrt(out_r[i]*out_r[i]+out_im[i]*out_im[i]); // to  increase the speed delete sqrt
         out_im[i]=i*Frequency/N;
         /*
         Serial.print(out_im[i]); Serial.print("Hz");
         Serial.print("\t");                            // un comment to print freuency bin    
         Serial.println(out_r[i]); 
         */    
        }




x=0;       // peak detection
   for(int i=1;i<data[o-1]-1;i++)
      {
      if(out_r[i]>out_r[i-1] && out_r[i]>out_r[i+1]) 
      {in_ps[x]=i;    //in_ps array used for storage of peak number
      x=x+1;}    
      }


s=0;
c=0;
    for(int i=0;i<x;i++)             // re arraange as per magnitude
    {
        for(int j=c;j<x;j++)
        {
            if(out_r[in_ps[i]]<out_r[in_ps[j]]) 
                {s=in_ps[i];
                in_ps[i]=in_ps[j];
                in_ps[j]=s;}
        }
    c=c+1;
    }



    for(int i=0;i<5;i++)     // updating f_peak array (global variable)with descending order
    {
    f_peaks[i]=out_im[in_ps[i]];
    }



}
    

float sine(int i)
{
  int j=i;
  float out;
  while(j<0){j=j+360;}
  while(j>360){j=j-360;}
  if(j>-1   && j<91){out= sine_data[j];}
  else if(j>90  && j<181){out= sine_data[180-j];}
  else if(j>180 && j<271){out= -sine_data[j-180];}
  else if(j>270 && j<361){out= -sine_data[360-j];}
  return (out/255);
}

float cosine(int i)
{
  int j=i;
  float out;
  while(j<0){j=j+360;}
  while(j>360){j=j-360;}
  if(j>-1   && j<91){out= sine_data[90-j];}
  else if(j>90  && j<181){out= -sine_data[j-90];}
  else if(j>180 && j<271){out= -sine_data[270-j];}
  else if(j>270 && j<361){out= sine_data[j-270];}
  return (out/255);
}

//------------------------------------------------------------------------------------//

Gibt es das nicht in einfach und verständlicher???

FFT heißt Fast Fourier Transform.
Eine Wechselspannung kann dadurch in ihre Frequenzen aufgesplittet werden.

Ein Radarsensor sendet eine elektromagnetishe Welle aus. Die wird durch ein Objekt reflektiert.
Ist das Objekt relativ zu Sensor in Bewegung so ändert sich die Frequenz der zurückgeworfenen elektromagnetischen Welle (Dopplereffekt). Aus der Änderung der Frequenz der zurückgeworfenen Welle kann man die relative Geschwindigkeit Objekt-Sensor errechnen.

Der Radarsensor mischt die Sendefrequenz mit der empfangenen Frequenz und erzeugt so ein Signal das die Frequenz hat die sich aus der Differenz zwischen Sendesignal und Empfangssignal ergibt.

Hat man nur ein Objekt das sich bewegt bekommt man auch nur eine Frequenz. Hat man mehrere Objekte die sich bewegen dann bekommt man auch ein Signal das aus mehreren Frequenzan zusammensetzt.
Mit der FFT kann man diese Frequenzen auseinanderrechen und so ein Spektrum der Frequenzen erhalten.

Es gibt 2 Möglichkeiten den Sensor zu betreiben:

  • Als Näherungsschalter wie ein PIR wobei eine Bewegung zum, bzw vom Sensor dedektiert wird (PIR erkennt Seitliche Bewegung). Ma kontrolliert das Vorhadensein eines Signals.
  • Für die Geschwindigkeitsmessung: Man mißt die Frequenz des Ausgangssignals.

Theoretisch könnte man so fast jede beliebige Geschwindigkeit messen, aber eingebaute Filter, die zur Störungsunterdrückung notwendig sind, beschneiden die minimale und maximale Frequenz des Ausgangssignals.

aus: https://shop.weidmann-elektronik.de/index.php?page=product&info=8
Bandbreite: 60-11000 Hz (1 km/h - ca. 200 km/h)

Natürlich muß man die 50 Hz Netzfrequenz herausfiltern da diese überall und stark vorhaden ist. Über 20kHz sind Switchingnetzteile aktiv. Auch diese stören die Messung.

Für den Arduino gibt es eine FFT- Bibliothek.
Bei nur einem bewegten Objekt müßte eine Frequenzmessung des Signals des Sensors genügen.
Aber ich gebe dem Ratgeber sicher recht daß bei Autorennen schon mal Zuschauer im Blickfeld des Sensors sein können und diese Duch Bewegung die Messung stören.

Auch zu bedenken ist der Winkel zwischen Sensor und Geschwindigkeit. Nur wenn sich das Objekt genau zum oder von Radarsensor weg bewegt ist die Messung richtig. Ist Ist zwischen Bewegungsrichtung und Sensorachse ein Winkel muß dieser berücksichtigt werden. Da Du laut Bild https://aws1.discourse-cdn.com/arduino/original/4X/9/0/b/90b7bebf4b2004ad0bf7b90ed3efe7f3f65fcd52.jpeg den Sensor auf dem Gimbal beweglich montierst ist eine Messung der Winkelposition zur Berechnung des Geschwindigkeit notwendig.
Außerdem sind die Schrittmotore sehr gute Störquellen im für den Radarsensor interessanten Frequenzbereich.

Ich würde andere Geschwindigkeitsmessungsmethoden vorziehen. ZB doppelte Lichtschranke oder fertige Geschwindigkeitsmeßsysteme auf Radarbasis.

Grüße Uwe

1 Like

Wow vielen herzlichen dank für deine sehr ausführliche erklärung!!

Hättest du dazu eventuel einen link mit einer "für mich :see_no_evil: " verständlichen erklärung?

Nein! Das ist eigentlich so gut wie ausgeschloßen!!
Ich habe das Gerät ja gebaut um die kamera selbst nicht mehr bedienen zu müssen weil ich sehr gerne als Streckenposten im" Einsatz" bin und da hat man so gewise vorzüge zum "normalen" puplikum!

Der Gimball bewegt sich in dem sinn wärend einer messung nicht und ist an einem festen punkt.

Oh das ist schlecht mit den schrittmotore. Ich habe es im moment ein wenig verschwenderschisch gestaltet.
Auf ein arduino habe ich die steuerung an sich gemacht. ich steuere damit 4 relais an. Auf einem anderen zweiten sizt dann das motorshield für die 2 schrittmotore und das ist mit den 4 relais verbunden. als High/LOW so zu sagen ( wenn relais 1 bzw. der jeweilige pin high dann schrittmor nach links usw....)

Die stromversorgung ist dadurch auch von einander getrennt.

Lichtschranken zur Geschwindigkeitsmessung scheiden so ziemlich aus. Da das ganze dann noch mehr Gerätschaften erfordert und dann zusätzlich z.b. jeweils noch zusätzlich ein funkmodul oder ähnliches erfordert da das ganze zu verkabeln ist so ja nahezu nicht umsetzbar.

Grüße

Georg

Lichtschranken können Reflecktionslichschranken sein und so braucht es auf der Gegenseite nur ein Katzenauge. Der Abstand kann 1-2 m betragen und darum ist der Aufbau einfach.

Grüße Uwe

Ja... Wie schon ganz am anfang erwähnt habe ich bereits eine lichtschranke die ich zur foto auslösung verwende.
Dazu habe ich auf 1 nano die lichtschrank und diese mit NRF24L01 und einem relais für das "steuer arduino" verwendet.

So ich hab da was gefunden nachdem ich ein paar loíbarys durchsucht habe ein beispiel gefunden.
Nur habe ich dazu keine erklärung :frowning:

*/

#include "arduinoFFT.h"

arduinoFFT FFT = arduinoFFT(); /* Create FFT object */
/*
These values can be changed in order to evaluate the functions
*/
#define CHANNEL A0
const uint16_t samples = 64; //This value MUST ALWAYS be a power of 2
const double samplingFrequency = 100; //Hz, must be less than 10000 due to ADC

unsigned int sampling_period_us;
unsigned long microseconds;

/*
These are the input and output vectors
Input vectors receive computed results from FFT
*/
double vReal[samples];
double vImag[samples];

#define SCL_INDEX 0x00
#define SCL_TIME 0x01
#define SCL_FREQUENCY 0x02
#define SCL_PLOT 0x03

void setup()
{
  sampling_period_us = round(1000000*(1.0/samplingFrequency));
  Serial.begin(115200);
  while(!Serial);
  Serial.println("Ready");
}

void loop()
{
  /*SAMPLING*/
  microseconds = micros();
  for(int i=0; i<samples; i++)
  {
      vReal[i] = analogRead(CHANNEL);
      vImag[i] = 0;
      while(micros() - microseconds < sampling_period_us){
        //empty loop
      }
      microseconds += sampling_period_us;
  }
  /* Print the results of the sampling according to time */
  Serial.println("Data:");
  PrintVector(vReal, samples, SCL_TIME);
  FFT.Windowing(vReal, samples, FFT_WIN_TYP_HAMMING, FFT_FORWARD);	/* Weigh data */
  Serial.println("Weighed data:");
  PrintVector(vReal, samples, SCL_TIME);
  FFT.Compute(vReal, vImag, samples, FFT_FORWARD); /* Compute FFT */
  Serial.println("Computed Real values:");
  PrintVector(vReal, samples, SCL_INDEX);
  Serial.println("Computed Imaginary values:");
  PrintVector(vImag, samples, SCL_INDEX);
  FFT.ComplexToMagnitude(vReal, vImag, samples); /* Compute magnitudes */
  Serial.println("Computed magnitudes:");
  PrintVector(vReal, (samples >> 1), SCL_FREQUENCY);
  double x = FFT.MajorPeak(vReal, samples, samplingFrequency);
  Serial.println(x, 6); //Print out what frequency is the most dominant.
  while(1); /* Run Once */
  // delay(2000); /* Repeat after delay */
}

void PrintVector(double *vData, uint16_t bufferSize, uint8_t scaleType)
{
  for (uint16_t i = 0; i < bufferSize; i++)
  {
    double abscissa;
    /* Print abscissa value */
    switch (scaleType)
    {
      case SCL_INDEX:
        abscissa = (i * 1.0);
	break;
      case SCL_TIME:
        abscissa = ((i * 1.0) / samplingFrequency);
	break;
      case SCL_FREQUENCY:
        abscissa = ((i * 1.0 * samplingFrequency) / samples);
	break;
    }
    Serial.print(abscissa, 6);
    if(scaleType==SCL_FREQUENCY)
      Serial.print("Hz");
    Serial.print(" ");
    Serial.println(vData[i], 4);
  }
  Serial.println();
}

Mein Sensor hat ja 24 GHz also muss ich das hier hier eintragen oder?
Aber wieviel Hz denn der sensor hat ja eine Bandbreite von 60-11000 Hz

const uint16_t samples = 64; //This value MUST ALWAYS be a power of 2
const double samplingFrequency = 100; //Hz, must be less than 10000 due to ADC

Welche Werte muss ich noch verändern?

Grüße

Wenn Du bereits 1 Lichtschranke hast dann baue eine zweite im Abstand von einem Meter dazu. Durch die Differenz der Auslösung kann sich einfach die Geschwindigkeit errechnen.

Grüße Uwe

Ja, mit einem 125kHz A/D Wandler dann 24GHZ Samplen. Wäre schön daß das funktioniert.

Nein, die 24 GHz bedeuten hier gar nichts. Ist so als wenn eine Lichtschranke grünes oder rotes Licht hätte.

Die Konstante "samles" ist die Anzahl der analogen Meßwerte die für die FFT verwendet werden.
Die Konstante "samplingFrequency" ist die Frequenz mit der das Signal gemessen wird. Die Theorie sagt daß mindestens mit der dopelten Signalfrequenz abgetastet werden muß. also bei 11kHz mindestens mit 22kHz. Ich weiß aber nicht ob das für die Anspruche der FFT Berechnung genügt.

Im Beispiel liest Du 64 Werte im Abstans von 1/100 Sekunde (also jede 10mS) ein.

Wie bereits gesagt die messung der Geschwindigkeit Durch Radar und FFT ist nicht so einfach und für einen Anfänge umzusetzen. Ich selbst würde mich da nicht heranwagen. Schauen wir mal ob jemand das schon gemacht hat und welche Erfahrungen er gemacht hat.

Grüße Uwe

Ich weiß es jetzt ehrlich gesagt auch nicht so recht :confused:

Ich mein man muss ja auch mal sehen was ich da sol alles mit mir rum schleppen muss...
Funkgerät, Klapstuhl, Flaggen, essen/trinken,Kamera, Gimball, Dreibein für diesen, im moment noch Autobatterie (zwecks der stromversorgung aber die will ich loswerden und bin nebenbei daran eine "powerbox" mit einer munitionskiste zu bauen), kleines dreibein mit Lichtschranke + das gegenstück als reflektor, und dann nochmal eine dazu.
Das is halt schon viel.....
Und dann ist ja noch das problem dass die lichtschranke einen exakten abstand von einem meter z.b. braucht damit das ergebniss stimmt. und es dauert ja auch seine zeit bis alles auf und ab-gebaut ist und wenn ich an z.b. die Jänner Rallye in Österreich anfang januar jedesmal denke wird es schon grusselig :see_no_evil: von ganz früh morgens bis spät abends bei starken winter wetter(schneefall eiskalt und wind :see_no_evil: juhu) irgendwo im nix stehen und warten bis es los geht und wieder endet und dann musst alles auf und abbauen. Das muss man dann schon mögen wollen :rofl: :rofl: :rofl:

ich denke an sowas:


Einfach einen waagerechten Balken auf das Stativ montieren und an den Enden die 2 Lichtschranken (Im Foto sind es 3).
Ich weiß jetzt nicht was die beste Distanz der 2 Lichtschranken ist. Je näher desto kürzer ist die Zeit. Wäre durchzurechnen wie die Zeiten bei gegebenen Geschwindigkeiten sind.

Zum Transportproblem: zusammenklapbare Sackkarre.

Grüße Uwe

Ui dankeschön für den hinweis/Tipp!

Könnte man das eigentlich auch anders machen?

Z.b. wenn 2 Uktraschallsensoren verwendet werden? Ich habe noch nie getestet ob vieleicht so einen sensor wie HC04Sr in eine röhre baut ob das dann relativ "zielgerichtet" wäre...

So bräuchte man keinen reflektor :face_with_monocle:

Ultraschall funktioniert nicht.
Mann hat da keine kontinuirliche Messung sondern man schickt einen kurzen Ton und wartet auf das Echo. Das dauert dann ca 1 Sekunde.

Grüße Uwe

Danke für die erläuterung :slight_smile:

Ich habe jetzt was gefunden und direkt ein wenig imn wohnzimmer getestet :see_no_evil:
auf dieser seltsam verlinkten seite

Ist zwar für einen anderen sensor, ein HB100, ein github link mit lib und beispielcode inkl lcd code :slight_smile:

Im serielen monitor funktiert es wenn ich darauf zu laufe :slight_smile:

// Below: pin number for FOUT
#define PIN_NUMBER 5
// Below: number of samples for averaging
#define AVERAGE 4
// Below: define to use serial output with python script
//#define PYTHON_OUTPUT
unsigned int doppler_div = 19;
unsigned int samples[AVERAGE];
unsigned int x;

void setup() {
  Serial.begin(115200);
  pinMode(PIN_NUMBER, INPUT);
}

void loop() {
  noInterrupts();
  pulseIn(PIN_NUMBER, HIGH);
  unsigned int pulse_length = 0;
  for (x = 0; x < AVERAGE; x++)
  {
    pulse_length = pulseIn(PIN_NUMBER, HIGH); 
    pulse_length += pulseIn(PIN_NUMBER, LOW);    
    samples[x] =  pulse_length;
  }
  interrupts();

  // Check for consistency
  bool samples_ok = true;
  unsigned int nbPulsesTime = samples[0];
  for (x = 1; x < AVERAGE; x++)
  {
    nbPulsesTime += samples[x];
    if ((samples[x] > samples[0] * 2) || (samples[x] < samples[0] / 2))
    {
      samples_ok = false;
    }
  }

  if (samples_ok)
  {
    unsigned int Ttime = nbPulsesTime / AVERAGE;
    unsigned int Freq = 1000000 / Ttime;

    #ifdef PYTHON_OUTPUT
      Serial.write(Freq/doppler_div);
    #else
      //Serial.print(Ttime);
      Serial.print("\r\n");
      Serial.print(Freq);
      Serial.print("Hz : ");
      Serial.print(Freq/doppler_div);
      Serial.print("km/h\r\n");
    #endif
  }
  else
  {
    #ifndef PYTHON_OUTPUT
      Serial.print(".");
    #endif
  }
}

ich denke zwar irgendwas passt daran noch nicht denn es wird wenn sich absolut nichts bewegt im serielen Monitor das angezeigt: 65535Hz : 3449km/h

Nicht verwunderlich.
Die Zahl ist der obere Maximale Wert, der in der Variablen gespeichert werden kann. :wink: