Le principe de fonctionnement

L’effet Doppler, ou effet Doppler-Fizeau*, est le décalage de fréquence d’une onde (acoustique ou électromagnétique) observée entre les mesures à l’émission et à la réception, lorsque la distance entre l’émetteur et le récepteur varie au cours du temps.
Le capteur Doppler HB100 embarque à la fois un émetteur radio hyperfréquence à 10.525 GHz et un récepteur opérant sur la même bande de fréquence. Les antennes distinctes sont gravées sur le circuit imprimé. Les composants utilisés (transistor et diodes résistances et capacités) sont abrités sous un capot en aluminium.
La fréquence d’oscillation est stabilisée par un résonateur céramique. Un réglage de la fréquence est si nécessaire ajustable par une vis.
* Le physicien Hippolyte Fizeau (1819-1896) possède sa maison au Mont-Valérien à Suresnes.
Grace à l’établissement d’une liaison optique entre sa maison et Montmartre, il réalise des mesures sur la vitesse de la lumière (vitesse mesurée en 1849 à 315 300 km/s au lieu de 299 792 km/s). H. Fizeau fait partie des savants dont les noms sont inscrits en lettre d’or sur le bandeau du premier étage de la Tour Eiffel.

Le capteur Doppler HB100

Le composant HB100 délivre un signal d’un niveau très faible (20 mV) à la sortie FI du mélangeur à doubles diodes.
A la fréquence de 10 GHz, les différences de fréquences entre l’onde émise et l’onde reçue sont faibles, de l’ordre de quelques dizaines de Hz pour des déplacements effectués à une vitesse de quelques km/h.
Un montage complémentaire opérant en basse fréquence est donc nécessaire pour amplifier puis numériser l’information provenant du HB100. Un microcontrôleur Arduino est aussi nécessaire pour convertir les fréquences détectées en valeurs numériques affichables. L’affichage pourra être effectué sur un afficheur LCD, un afficheur LED 7 segments ou dans notre cas sur un écran de PC.

Le montage électronique

Le montage utilise des amplificateur opérationnels LM324 qui sont conçus pour fonctionner à basse tension d’alimentation (5 Volts) et aussi pour offrir des sorties aptes à balayer sur toute l’amplitude entre 0 et 5V. (caractéristique appelé « Rail to Rail »).
Pour travailler avec des niveaux de signaux plus élevés, le premier ampli OP UA1 est configuré pour fournir un gain de 100 (R4/R2 =100). Une capacité C2 est mise en parallèle avec la résistance R4 pour réaliser un filtre passe-bas apportant une fréquence de coupure à 3dB autour de 80 Hz. En Effet, les fréquence au-dessus de 80 Hz risquent de perturber la mesure.

Application numérique : RCw = 1 , w = 2 π f avec R = 1M Ω et C = 2.2nF ) donne 80Hz.

Un pont diviseur résistif R1/R3 polarise l’entrée de cet ampli Op à 2.5V, une capacité de découplage C3 évite tous bruits provenant de l’alimentation sur l’entrée – de UA1. Une capacité de liaison C1 coupe la composante continue provenant du circuit HB100.
Le second ampli OP est monté en comparateur avec une fonction d’hystérésis pour présenter des signaux numériques compatibles avec l’entrée D8 de l’Arduino. Une résistance variable est placée entre l’alimentation 5V et la masse GND pour régler le seuil du comparateur juste au-dessus du bruit de fond provenant du HB100. Cela va éviter de faire travailler l’Arduino sur des signaux trop faibles ou sur des bruits. Un montage de l’ampli Op en « trigger de Schmitt » apporte un décalage du seuil de commutation et évite les basculement multiples constatés après les dépassements d’un seuil unique par des signaux à temps de montée lent et bruité (voir la figure ci-dessous) . Le rapport entre R6 et R5 détermine l’écart entre le seuil haut et le seuil bas de l’ordre de 1/100 de Vcc soit de l’ordre de 50 mV.

Seuils de basculement avec hystérésis

Schéma de montage éléctronique

Le programme Arduino

Le programme exécuté par l’Arduino effectue la mesure de la période du signal. Ce signal, issu de la sortie de l’ampli Op U1B est présenté à l’entrée D8 de l’Arduino. La librairie « Freqmeasure » travaille par interruption avec un compteur déclenché par les transitions observées sur l’entrée A8. Une moyenne sur plusieurs périodes est calculée (3 ou 4 périodes). La période T (ms) est transformé en fréquence F (Hertz) par la formule F = 1/T.
Un calcul de la valeur maximum est effectué sur plusieurs mesures courantes consécutives.

Les données « fréquence courante » et « fréquence maximum » peuvent être présentées sur des afficheurs numériques (LCD ou LED) ou transmis en mode série sur l’interface USB pour affichage sur un PC grâce à une application Processing.
Pour transmettre les deux informations en même temps une notation Json est mise en œuvre, elle permet de transférer en mode série les deux valeurs dans une seule chaine de caractères. Voir la commande « serializeJson (doc, Serial) ». La librairie « ArduinoJson » doit donc être ajoutée dans l’IDE Arduino.

Le code Arduino :

/*
* La mesure se fait par calcul de la période du signal Doppler
* S’agissant de basses fréquences on prend la mesure que sur 4 boucles ( count) pour ne pas ralentir la mesure
*/
#include <FreqMeasure.h>
#include <ArduinoJson.h>

float maxVal = 0; // Initialiser avec la première valeur du tableau
float frequency;
unsigned long tempo;
int i=0;
double sum=0;
int count=0;

void setup() {
Serial.begin(57600);
while (!Serial) continue;
FreqMeasure.begin();
}

void loop() {
i=i+1;
if (FreqMeasure.available())
{
tempo = millis();
// average several reading together
sum = sum + FreqMeasure.read();
count = count + 1;
if (count >= 4)
{
// après 4 boucles calcul de la frequence moyenne
frequency = FreqMeasure.countToFrequency(sum / count);
sum = 0;
count = 0;
}
} // fin mesure available

// timeout de la mesure pour remise à zero de la frequence en abscence de signal reçu du HB100
if (millis() > (tempo +1000) )
{
frequency= 0;
}

//Calcul de la valeur max
maxVal = max(maxVal, frequency); // Comparer et stocker la valeur maximale
{

// formation de la chaîne de caractères json
JsonDocument doc;
doc[« Doppler »] = « HB100 »;
doc[« courant »] = frequency;
doc[« MAX »] = maxVal;

if (i%1000 == 0) // on ne sérialise que tous les 100 boucles loop
{
serializeJson(doc, Serial);
// Start a new line
Serial.println();
i=1;
}
}
}

Le programme Processing

Processing est un langage simple pour produire des applications multimédia il est basé sur le langage Java mais cache complément la compléxité de ce langage. Un autre langage similaire est P5JS qui lui est basé sur Javascript et sert surtout pour des applications tournant sur un navigateur Web.

Depuis 2001, Processing est exploité dans les arts visuels et sonores. Des dizaines de milliers d’artistes, de designers, de chercheurs et d’amateurs utilisent Processing.

Le programme Processing doit être configuré sur le même interface série COMx que celui de l’Arduino.
Dans le programme Processing les fonctions d’analyse Json sont natives, elles restituent les valeurs courantes et maximum de la fréquence en provenance de l’Arduino. Processing offre une multitude de modes d’affichage sur l’écran du PC : par exemple en mode « texte » ou en mode « graphique » ou les deux.
Code Processing :

//F6KFA Alain Bertout Octobre 202 effet doppler
import processing.serial.*;
int startTime;
Float courant;
Float MAX;
int lf = 10; // Linefeed in ASCII
String data = « {\ »Doppler\ »:\ »gps\ »,\ »courant\ »:\ »0\ »,\ »MAX\ »:\ »0\ »} »;
Serial myPort; // The serial port
JSONObject json;
PImage img;

void setup() {
fullScreen();
background(0);
img = loadImage(« milkyway-8190232_ASUS.jpg »);
startTime = millis(); // Enregistre le temps de départ
// List all the available serial ports
printArray(Serial.list());
// Open the port you are using at the rate you want:
myPort = new Serial(this, Serial.list()[1], 57600);
myPort.clear();
// Throw out the first reading, in case we started reading
// in the middle of a string from the sender.
image(img, 0, 0); // chargement de l'image de fond d'écran milky way
}
void draw() {
while (myPort.available() > 0)
{
data = myPort.readStringUntil(lf);
}
if (data != null)
{
print (« data = « );
println(data);
}
JSONObject json = parseJSONObject(data);
if (json == null)
{
println(« JSONObject could not be parsed »);
} else
{
courant = json.getFloat(« courant »);
// println(courant);
MAX = json.getFloat(« MAX »);
fill(200, 200, 0);

int elapsedTime = millis() – startTime; // Calcule le temps écoulé (axe des temps)
textSize(40);
textAlign(LEFT);
text(« L'effet Doppler-Fizeau permet, par la radio, de mesurer une vitesse » , 20, 40);
textAlign(CENTER);
//text(« Temps: » + elapsedTime/500 + » s », elapsedTime/25, 80);
fill(200, 0, 0);
ellipse(elapsedTime/25, displayHeight-40-MAX*4, 40, 40);
//text(MAX*.108, elapsedTime/25, displayHeight-20-MAX*2-50);
fill(0, 100, 200);
ellipse(elapsedTime/25, displayHeight-40-courant*4, 40, 40);
//text(courant*.108, elapsedTime/25, displayHeight-20-courant*2-50);
stroke(200);
line (0,displayHeight-20, elapsedTime/25,displayHeight-20);
if (elapsedTime/25> displayWidth) { startTime = millis();
image(img, 0, 0); // rechargement du fond d'écran à la fin du Draw
}
}
}
Sur l’écran du PC, au cours du temps (axe des x), les valeurs courantes des vitesses sont affichées sous forme de boules bleues (axe des y), les valeurs maximums atteintes s’inscrivent sous forme de boules rouges sur un fond d’écran stellaire.

L’écran d’affichage des fréquences Doppler par Processing