Fabrication d’un radar commandé par Arduino UNO et HC-SR04

Arduino UNO 19-11-24

98 0

Plan du tutoriel

1- Qu'est ce qu'un radar ?

2- Comment il fonctionne le radar commandé par Arduino ?

3- Les composants du radar

4- Schéma de câblage du radar

5- Programmation du radar

Qu'est ce qu'un radar ?

Un radar (acronyme de Radio Détection et Range) est un système électronique qui utilise des ondes radio pour détecter, localiser et suivre des objets à distance. Le principe de fonctionnement du radar repose sur l'émission d'impulsions radio qui se propagent dans l'espace. Lorsqu'elles rencontrent un objet (comme un avion, un bateau, une voiture, ou des phénomènes météorologiques), ces ondes sont réfléchies vers l'émetteur. En analysant le temps écoulé entre l'émission et la réception des ondes réfléchies, ainsi que leur fréquence modifiée (effet Doppler), le radar peut déterminer la distance, la vitesse et parfois la taille ou la forme de l'objet détecté.

Applications du radar

1. Aviation et maritime : Les radars sont essentiels pour la navigation, permettant de détecter d'autres aéronefs, navires ou obstacles, surtout dans des conditions de visibilité réduite comme le brouillard ou la nuit.

2. Météorologie : Les radars météorologiques surveillent les conditions atmosphériques en détectant les précipitations, leur intensité et leur mouvement, aidant ainsi à prévoir les tempêtes et autres phénomènes météorologiques.

3. Sécurité routière : Les radars sont utilisés par la police pour mesurer la vitesse des véhicules et contrôler le respect des limitations de vitesse.

4. Applications militaires : Les radars militaires servent à détecter des avions, des missiles, des navires ou d'autres cibles potentielles, jouant un rôle crucial dans la défense et la surveillance.

5. Recherche et sauvetage : En permettant de localiser des objets ou des personnes dans des environnements difficiles, les radars facilitent les opérations de secours.

Comment il fonctionne le radar commandé par Arduino ?

Étape 1 : Emission et réception du signal ultrasonique

Le capteur HC-SR04 émet une impulsion sonore à travers son émetteur ultrasonique (Trigger).

Cette impulsion se réfléchit sur un objet et revient au capteur par le récepteur (Echo).

L’Arduino mesure le temps entre l’envoi et la réception du signal.

La distance est calculée.

Étape 2 : Balayage avec le servomoteur

Le servomoteur fait pivoter le capteur HC-SR04 dans une plage angulaire définie (par exemple, de 0° à 180°).

À chaque angle, l’Arduino mesure la distance détectée par le capteur.

Ces mesures sont envoyées à l'ordinateur pour un traitement et une visualisation.

Étape 3 : Visualisation sur ordinateur

Les données (distance et angle) sont transmises à l'ordinateur via le port série de l’Arduino.

Un logiciel (comme Processing) les utilise pour créer une représentation graphique en temps réel sous forme de radar circulaire.

Les composants du radar

Arduino UNO :

Arduino Uno

Elle Sert de microcontrôleur pour coordonner les capteurs et le servomoteur.

HC-SR04 :

HC-SR04

C'est un capteur à ultrasons qui mesure la distance d’un objet en envoyant une onde sonore et en mesurant le temps qu’elle met à revenir.

Servomoteur :

Il permet de faire pivoter le capteur ultrasonique pour couvrir un angle donné.

Ordinateur :

Il reçoit les données via le port série pour afficher les résultats sous forme de radar graphique (par exemple, avec Processing ou Python).

Schéma de câblage du radar

1. HC-SR04 :

Trigger → Pin numérique de l’Arduino (D4)

Echo → Pin numérique (D5)

VCC → 5V de l’Arduino

GND → GND de l’Arduino

2. Servomoteur :

Signal → Pin numérique (D3)

VCC → 5V de l’Arduino

GND → GND commun avec l’Arduino

Programmation du radar

1- Exemple de code Arduino

#include <Servo.h>

Servo servo_1; // servo controller (multiple can exist)
int trig = 4; // trig pin for HC-SR04
int echo = 5; // echo pin for HC-SR04
int servo_pin = 3; // PWM pin for servo control
int pos = 0;    // servo starting position
float duration,distance;

void setup() {
  Serial.begin(115200);
  Serial.println("Radar Start");
  servo_1.attach(servo_pin); // start servo control
  pinMode(trig,OUTPUT);
  pinMode(echo,INPUT);
}

void loop() {
  for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
    // in steps of 1 degree
    servo_1.write(pos);              // tell servo to go to position in variable 'pos'
    delay(60); // delay to allow the servo to reach the desired position
    dist_calc(pos);
  }

  for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
    servo_1.write(pos);              // tell servo to go to position in variable 'pos'
    delay(60);
    dist_calc(pos);
  }
}

float dist_calc(int pos){
  // trigger 40kHz pulse for ranging
  digitalWrite(trig,LOW);
  delayMicroseconds(2);
  digitalWrite(trig,HIGH);
  delayMicroseconds(10);
  digitalWrite(trig,LOW);
  // convert from duration for pulse to reach detector (microseconds) to range (in cm)
  duration = pulseIn(echo,HIGH); // duration for pulse to reach detector (in microseconds)
  distance = 100.0*(343.0*(duration/2.0))/1000000.0; // 100.0*(speed of sound*duration/2)/microsec conversion

  Serial.print(pos); // position of servo motor
  Serial.print(","); // comma separate variables
  Serial.println(distance); // print distance in cm

}

#include <Servo.h>

Servo servo_1; // servo controller (multiple can exist)

int trig = 4; // trig pin for HC-SR04

int echo = 5; // echo pin for HC-SR04

int servo_pin = 3; // PWM pin for servo control

int pos = 0; // servo starting position

float duration,distance;

void setup() {

Serial.begin(115200);

Serial.println("Radar Start");

servo_1.attach(servo_pin); // start servo control

pinMode(trig,OUTPUT);

pinMode(echo,INPUT);

}

void loop() {

for (pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees

// in steps of 1 degree

servo_1.write(pos); // tell servo to go to position in variable 'pos'

delay(60); // delay to allow the servo to reach the desired position

dist_calc(pos);

}

for (pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees

servo_1.write(pos); // tell servo to go to position in variable 'pos'

delay(60);

dist_calc(pos);

}

float dist_calc(int pos){

// trigger 40kHz pulse for ranging

digitalWrite(trig,LOW);

delayMicroseconds(2);

digitalWrite(trig,HIGH);

delayMicroseconds(10);

digitalWrite(trig,LOW);

// convert from duration for pulse to reach detector (microseconds) to range (in cm)

duration = pulseIn(echo,HIGH); // duration for pulse to reach detector (in microseconds)

distance = 100.0*(343.0*(duration/2.0))/1000000.0; // 100.0*(speed of sound*duration/2)/microsec conversion

Serial.print(pos); // position of servo motor

Serial.print(","); // comma separate variables

Serial.println(distance); // print distance in cm

}

2- Visualisation dans l'ordinateur (avec Python)

Voici un exemple pour afficher un radar graphique avec Python :

# Python + Arduino-based Radar Plotter
#
# ** Works with any motor that outputs angular rotation
# ** and with any distance sensor (HC-SR04, VL53L0x,LIDAR)
#
import numpy as np
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from matplotlib.widgets import Button
import serial,sys,glob
import serial.tools.list_ports as COMs
#
#
############################################
# Find Arudino ports, select one, then start communication with it
############################################
#
def port_search():
    if sys.platform.startswith('win'): # Windows
        ports = ['COM{0:1.0f}'.format(ii) for ii in range(1,256)]
    elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):
        ports = glob.glob('/dev/tty[A-Za-z]*')
    elif sys.platform.startswith('darwin'): # MAC
        ports = glob.glob('/dev/tty.*')
    else:
        raise EnvironmentError('Machine Not pyserial Compatible')

    arduinos = []
    for port in ports: # loop through to determine if accessible
        if len(port.split('Bluetooth'))>1:
            continue
        try:
            ser = serial.Serial(port)
            ser.close()
            arduinos.append(port) # if we can open it, consider it an arduino
        except (OSError, serial.SerialException):
            pass
    return arduinos

arduino_ports = port_search()
ser = serial.Serial(arduino_ports[0],baudrate=115200) # match baud on Arduino
ser.flush() # clear the port
#
############################################
# Start the interactive plotting tool and
# plot 180 degrees with dummy data to start
############################################
#
fig = plt.figure(facecolor='k')
win = fig.canvas.manager.window # figure window
screen_res = win.wm_maxsize() # used for window formatting later
dpi = 150.0 # figure resolution
fig.set_dpi(dpi) # set figure resolution

# polar plot attributes and initial conditions
ax = fig.add_subplot(111,polar=True,facecolor='#006d70')
ax.set_position([-0.05,-0.05,1.1,1.05])
r_max = 100.0 # can change this based on range of sensor
ax.set_ylim([0.0,r_max]) # range of distances to show
ax.set_xlim([0.0,np.pi]) # limited by the servo span (0-180 deg)
ax.tick_params(axis='both',colors='w')
ax.grid(color='w',alpha=0.5) # grid color
ax.set_rticks(np.linspace(0.0,r_max,5)) # show 5 different distances
ax.set_thetagrids(np.linspace(0.0,180.0,10)) # show 10 angles
angles = np.arange(0,181,1) # 0 - 180 degrees
theta = angles*(np.pi/180.0) # to radians
dists = np.ones((len(angles),)) # dummy distances until real data comes in
pols, = ax.plot([],linestyle='',marker='o',markerfacecolor = 'w',
                 markeredgecolor='#EFEFEF',markeredgewidth=1.0,
                 markersize=10.0,alpha=0.9) # dots for radar points
line1, = ax.plot([],color='w',
                  linewidth=4.0) # sweeping arm plot

# figure presentation adjustments
fig.set_size_inches(0.96*(screen_res[0]/dpi),0.96*(screen_res[1]/dpi))
plot_res = fig.get_window_extent().bounds # window extent for centering
win.wm_geometry('+{0:1.0f}+{1:1.0f}'.\
                format((screen_res[0]/2.0)-(plot_res[2]/2.0),
                       (screen_res[1]/2.0)-(plot_res[3]/2.0))) # centering plot
fig.canvas.toolbar.pack_forget() # remove toolbar for clean presentation
fig.canvas.set_window_title('Arduino Radar')

fig.canvas.draw() # draw before loop
axbackground = fig.canvas.copy_from_bbox(ax.bbox) # background to keep during loop

############################################
# button event to stop program
############################################

def stop_event(event):
    global stop_bool
    stop_bool = 1
prog_stop_ax = fig.add_axes([0.85,0.025,0.125,0.05])
pstop = Button(prog_stop_ax,'Stop Program',color='#FCFCFC',hovercolor='w')
pstop.on_clicked(stop_event)
# button to close window
def close_event(event):
    global stop_bool,close_bool
    if stop_bool:
        plt.close('all')
    stop_bool = 1
    close_bool = 1
close_ax = fig.add_axes([0.025,0.025,0.125,0.05])
close_but = Button(close_ax,'Close Plot',color='#FCFCFC',hovercolor='w')
close_but.on_clicked(close_event)

fig.show()

############################################
# inifinite loop, constantly updating the
# 180deg radar with incoming Arduino data
############################################
#
start_word,stop_bool,close_bool = False,False,False
while True:
    try:
        if stop_bool: # stops program
            fig.canvas.toolbar.pack_configure() # show toolbar
            if close_bool: # closes radar window
                plt.close('all')
            break
        ser_bytes = ser.readline() # read Arduino serial data
        decoded_bytes = ser_bytes.decode('utf-8') # decode data to utf-8
        data = (decoded_bytes.replace('\r','')).replace('\n','')
        #print(data.split(',')) 
        if start_word:
            vals = [float(ii) for ii in data.split(',')]
            print(vals)
            if len(vals)<2:
                continue
            angle,dist = vals # separate into angle and distance
            if dist>r_max:
                dist = 0.0 # measuring more than r_max, it's likely inaccurate
            dists[int(angle)] = dist
            if angle % 5 ==0: # update every 5 degrees
                pols.set_data(theta,dists)
                fig.canvas.restore_region(axbackground)
                ax.draw_artist(pols)

                line1.set_data(np.repeat((angle*(np.pi/180.0)),2),
                   np.linspace(0.0,r_max,2))
                ax.draw_artist(line1)

                fig.canvas.blit(ax.bbox) # replot only data
                fig.canvas.flush_events() # flush for next plot
        else:
            if data=='Radar Start': # stard word on Arduno
                start_word = True # wait for Arduino to output start word
                print('Radar Starting...')
            else:
                continue

    except KeyboardInterrupt:
        plt.close('all')
        print('Keyboard Interrupt')
        break

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

# Python + Arduino-based Radar Plotter

# ** Works with any motor that outputs angular rotation

# ** and with any distance sensor (HC-SR04, VL53L0x,LIDAR)

import numpy as np

import matplotlib

matplotlib.use('TkAgg')

import matplotlib.pyplot as plt

from matplotlib.widgets import Button

import serial,sys,glob

import serial.tools.list_ports as COMs

############################################

# Find Arudino ports, select one, then start communication with it

############################################

def port_search():

if sys.platform.startswith('win'): # Windows

ports = ['COM{0:1.0f}'.format(ii) for ii in range(1,256)]

elif sys.platform.startswith('linux') or sys.platform.startswith('cygwin'):

ports = glob.glob('/dev/tty[A-Za-z]*')

elif sys.platform.startswith('darwin'): # MAC

ports = glob.glob('/dev/tty.*')

else:

raise EnvironmentError('Machine Not pyserial Compatible')

arduinos = []

for port in ports: # loop through to determine if accessible

if len(port.split('Bluetooth'))>1:

continue

try:

ser = serial.Serial(port)

ser.close()

arduinos.append(port) # if we can open it, consider it an arduino

except (OSError, serial.SerialException):

pass

return arduinos

arduino_ports = port_search()

ser = serial.Serial(arduino_ports[0],baudrate=115200) # match baud on Arduino

ser.flush() # clear the port

############################################

# Start the interactive plotting tool and

# plot 180 degrees with dummy data to start

############################################

fig = plt.figure(facecolor='k')

win = fig.canvas.manager.window # figure window

screen_res = win.wm_maxsize() # used for window formatting later

dpi = 150.0 # figure resolution

fig.set_dpi(dpi) # set figure resolution

# polar plot attributes and initial conditions

ax = fig.add_subplot(111,polar=True,facecolor='#006d70')

ax.set_position([-0.05,-0.05,1.1,1.05])

r_max = 100.0 # can change this based on range of sensor

ax.set_ylim([0.0,r_max]) # range of distances to show

ax.set_xlim([0.0,np.pi]) # limited by the servo span (0-180 deg)

ax.tick_params(axis='both',colors='w')

ax.grid(color='w',alpha=0.5) # grid color

ax.set_rticks(np.linspace(0.0,r_max,5)) # show 5 different distances

ax.set_thetagrids(np.linspace(0.0,180.0,10)) # show 10 angles

angles = np.arange(0,181,1) # 0 - 180 degrees

theta = angles*(np.pi/180.0) # to radians

dists = np.ones((len(angles),)) # dummy distances until real data comes in

pols, = ax.plot([],linestyle='',marker='o',markerfacecolor = 'w',

markeredgecolor='#EFEFEF',markeredgewidth=1.0,

markersize=10.0,alpha=0.9) # dots for radar points

line1, = ax.plot([],color='w',

linewidth=4.0) # sweeping arm plot

# figure presentation adjustments

fig.set_size_inches(0.96*(screen_res[0]/dpi),0.96*(screen_res[1]/dpi))

plot_res = fig.get_window_extent().bounds # window extent for centering

win.wm_geometry('+{0:1.0f}+{1:1.0f}'.\

format((screen_res[0]/2.0)-(plot_res[2]/2.0),

(screen_res[1]/2.0)-(plot_res[3]/2.0))) # centering plot

fig.canvas.toolbar.pack_forget() # remove toolbar for clean presentation

fig.canvas.set_window_title('Arduino Radar')

fig.canvas.draw() # draw before loop

axbackground = fig.canvas.copy_from_bbox(ax.bbox) # background to keep during loop

############################################

# button event to stop program

############################################

def stop_event(event):

global stop_bool

stop_bool = 1

prog_stop_ax = fig.add_axes([0.85,0.025,0.125,0.05])

pstop = Button(prog_stop_ax,'Stop Program',color='#FCFCFC',hovercolor='w')

pstop.on_clicked(stop_event)

# button to close window

def close_event(event):

global stop_bool,close_bool

if stop_bool:

plt.close('all')

stop_bool = 1

close_bool = 1

close_ax = fig.add_axes([0.025,0.025,0.125,0.05])

close_but = Button(close_ax,'Close Plot',color='#FCFCFC',hovercolor='w')

close_but.on_clicked(close_event)

fig.show()

############################################

# inifinite loop, constantly updating the

# 180deg radar with incoming Arduino data

############################################

start_word,stop_bool,close_bool = False,False,False

while True:

try:

if stop_bool: # stops program

fig.canvas.toolbar.pack_configure() # show toolbar

if close_bool: # closes radar window

plt.close('all')

break

ser_bytes = ser.readline() # read Arduino serial data

decoded_bytes = ser_bytes.decode('utf-8') # decode data to utf-8

data = (decoded_bytes.replace('\r','')).replace('\n','')

#print(data.split(','))

if start_word:

vals = [float(ii) for ii in data.split(',')]

print(vals)

if len(vals)<2:

continue

angle,dist = vals # separate into angle and distance

if dist>r_max:

dist = 0.0 # measuring more than r_max, it's likely inaccurate

dists[int(angle)] = dist

if angle % 5 ==0: # update every 5 degrees

pols.set_data(theta,dists)

fig.canvas.restore_region(axbackground)

ax.draw_artist(pols)

line1.set_data(np.repeat((angle*(np.pi/180.0)),2),

np.linspace(0.0,r_max,2))

ax.draw_artist(line1)

fig.canvas.blit(ax.bbox) # replot only data

fig.canvas.flush_events() # flush for next plot

else:

if data=='Radar Start': # stard word on Arduno

start_word = True # wait for Arduino to output start word

print('Radar Starting...')

else:

continue

except KeyboardInterrupt:

plt.close('all')

print('Keyboard Interrupt')

break

Lorsque le programme tourne, le radar effectue un balayage dans une plage angulaire donnée, en mesurant les distances et en affichant les résultats sur l'ordinateur sous forme de points représentant les objets détectés.