Je vous présente aujourd'hui un contrôleur pour télémètre à ultrasons (de type SRF05 ou HC-SR04). La carte de développement est une carte FPGA Altera DE0-nano :Le fonctionnement de ce type de capteurs est résumé sur les chronogrammes ci-dessous (Trigger et Echo séparés) :
Une impulsion de 10μs minimum sur la broche Trigger du module va préparer l’envoi d’un train d’ultrasons. Quand le train d’ultrasons part, le signal Echo bascule à l’état haut (environ 750μs après l’impulsion du signal Trigger). Le signal Echo retourne à l’état bas au retour du train d’ultrasons après réflexion sur l’obstacle (ou après un timeout de 30ms si aucun obstacle n’est rencontré). La largeur du signal Echo représente le temps pris par le train d’ultrasons pour faire l’aller-retour entre le capteur et l’obstacle, et donc une image de la distance de l'obstacle (la vitesse du son étant connue, 345m/s environ).
Exemple : si la largeur du signal Echo relevée est de 20ms, alors la distance de l’obstacle est d = 345x0,02/2=3,45m environ (le facteur 1/2 s’explique car le train d’ultrasons parcourt deux fois la distance, aller et retour après réflexion, entre le capteur et l’obstacle).
Un contrôleur pour ce capteur doit donc être capable au minimum de produire un signal Trigger sur commande, et de récupérer finalement une donnée numérique qui sera l’image de la largeur du signal Echo.
Le module ultrasonic.v du contrôleur présente les entrées-sorties suivantes :
Les entrées :
- clk : le signal d’horloge (paramètre CLK_MHZ à renseigner, 50MHz par défaut) ;
- echo : à connecter sur la broche Echo du capteur (Attention, le capteur est alimenté en 5V, le signal Echo du capteur doit être abaissé à 3,3V à l’entrée de la carte FPGA (diviseur de tension) ;
- start : démarre une mesure avec une impulsion synchronisée sur une période du signal d’horloge.
Les sorties :
- trigger : à connecter à la broche Trigger du capteur. La paramètre TRIGGER_PULSE_US renseigne la durée de l’impulsion (12μs par défaut);
- new_measure : signal de contrôle, où une impulsion est générée quand la mesure est complète (signal Echo redescendu ou timeout) ;
- timeout : signal de contrôle, une impulsion si timeout (paramètre TIMEOUT_MS, 20ms par défaut) ;
- distance_raw : donnée image de la largeur du signal Echo codée sur 21 bits. Il s’agit en fait d’un compteur 21 bits qui s’incrémente à la fréquence de l’horloge jusqu’au retour des ultrasons (ou timeout). La valeur est garantie si vous lisez la valeur du compteur au moment de l’impulsion du signal new_measure.
Durée du signal Echo en microsecondes = distance_raw / CLK_MHZ
Le capteur SRF05 a un timeout de 30ms si aucun obstacle n'est rencontré. On peut simuler un timeout inférieur avec le paramètre TIMEOUT_MS. Si le signal Echo n'est pas redescendu après ce timeout, le contrôleur bloque distance_raw, délivre une impulsion sur la sortie new_measure et sur la sortie timeout.
Chronogrammes de simulation fonctionnelle :
Le processus est décrit à la façon d’une machine à états finis (Finite State Machine) :
Voici le code du module ultrasonic.v :
| Code verilog : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 | /*
* Un simple contrôleur pour les capteurs à ultrason
du type SRF05 ou HC-SR04
* Trigger et Echo séparés
/-----------------------------\
| ultrasonic sensor |
| controller |
| |
| trigger -->
| |
| new_measure -->
| timeout -->
--> echo |
| distance_raw[20:0] ==>
| |
--> start |
--> clk |
| |
\-----------------------------/
* clk : horloge (paramètre CLK_MHZ, 50 MHz par défaut)
* start : lance une mesure sur impulsion
* trigger : à connecter à la broche Trig du capteur
(paramètre TRIGGER_PULSE_US, 12 us par défaut)
* echo : à connecter sur la broche Echo du capteur
* new_measure : 1 impulsion si la mesure est complète
* timeout : 1 impulsion si timeout (paramètre TIMEOUT_MS, 20 ms par défaut
* distance_raw: à lire sur impulsion de new_measure
donnée image de la largeur du signal Echo codée sur 21 bits
duree du signal echo en microsecondes = distance_raw / CLK_MHZ
Le capteur SRF05 a un timeout de 30 ms si aucun obtacle n'est rencontré.
On peut simuler un timeout inférieur avec le paramètre TIMEOUT_MS
Si le signal Echo n'est pas redescendu après ce TIME_OUT, le contrôleur
bloque distance_raw, délivre une impulsion sur la sorte new_measure et sur la sortie timeout.
*/
module ultrasonic(clk, start, trigger, echo, distance_raw, new_measure, timeout);
input clk, start, echo;
output trigger, new_measure, timeout;
output reg [20:0] distance_raw;
parameter CLK_MHZ = 50, // fréquence horloge en MHz
TRIGGER_PULSE_US = 12, // durée impulsion trigger en microsecondes
TIMEOUT_MS = 25; // timeout en millisecondes
localparam COUNT_TRIGGER_PULSE = CLK_MHZ * TRIGGER_PULSE_US;
localparam COUNT_TIMEOUT = CLK_MHZ * TIMEOUT_MS * 1000;
reg [20:0] counter;
reg[2:0] state, state_next;
localparam IDLE = 0,
TRIG = 1,
WAIT_ECHO_UP = 2,
MEASUREMENT = 3,
MEASURE_OK = 4;
always @(posedge clk) state <= state_next;
wire measurement;
assign measurement = (state == MEASUREMENT);
assign new_measure = (state == MEASURE_OK);
wire counter_timeout;
assign counter_timeout = (counter >= COUNT_TIMEOUT);
assign timeout = new_measure && counter_timeout;
assign trigger = (state == TRIG);
wire enable_counter;
assign enable_counter = trigger || echo;
always @(posedge clk) begin
if (enable_counter)
counter <= counter + 21'b1;
else
counter <= 21'b0;
end
always @(posedge clk) begin
if (enable_counter && measurement)
distance_raw <= counter;
end
always @(*) begin
state_next <= state; // par défaut, état maintenu
case (state)
IDLE: begin // signal trigger sur impulsion start
if (start) state_next <= TRIG;
end
TRIG: begin // durée signal trig > 10us pour SRF05
if (counter >= COUNT_TRIGGER_PULSE) state_next <= WAIT_ECHO_UP;
end
WAIT_ECHO_UP: begin
// avec le SRF05, il y a un délai de 750us après le trig avant que le
// signal echo bascule à état haut.
if (echo) state_next <= MEASUREMENT;
end
MEASUREMENT: begin // attente echo qui redescend, ou timeout
if (counter_timeout || (~echo)) state_next <= MEASURE_OK;
end
MEASURE_OK: begin
state_next <= IDLE;
end
default: begin
state_next <= IDLE;
end
endcase
end
endmodule |
Le code ci-dessous est une petite démonstration qui met en œuvre le télémètre à ultrasons SRF05 (voir la vidéo plus haut). Le bandeau de LED de la carte progresse en fonction de la distance de l'obstacle face au capteur :
| Code verilog : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 | module top(CLOCK_50, TRIG, ECHO, LED);
input CLOCK_50;
output TRIG;
input ECHO; // /!\ Alim. du capteur 5V, abaisser le signal ECHO à 3v3 (diviseur tension)
output [7:0] LED;
wire start, new_measure, timeout;
wire [20:0] distance_raw;
reg [24:0] counter_ping;
localparam CLK_MHZ = 50; // horloge 50MHz
localparam PERIOD_PING_MS = 60; // période des ping en ms
localparam COUNTER_MAX_PING = CLK_MHZ * PERIOD_PING_MS * 1000;
// avec horloge 50MHz et c=345m/s, distance_raw = 2900 * D(cm)
localparam D = 2900;
ultrasonic #( .CLK_MHZ(50),
.TRIGGER_PULSE_US(12),
.TIMEOUT_MS(3)
) U1
( .clk(CLOCK_50),
.trigger(TRIG),
.echo(ECHO),
.start(start),
.new_measure(new_measure),
.timeout(timeout),
.distance_raw(distance_raw)
);
assign LED[6] = (distance_raw > 40*D); // distance > 40cm
assign LED[5] = (distance_raw > 30*D);
assign LED[4] = (distance_raw > 25*D);
assign LED[3] = (distance_raw > 20*D);
assign LED[2] = (distance_raw > 15*D);
assign LED[1] = (distance_raw > 10*D);
assign LED[0] = (distance_raw > 5*D); // distance > 5cm
assign LED[7] = timeout; // avec timeout=3ms => distance > 52cm
assign start = (counter_ping == COUNTER_MAX_PING - 1);
always @(posedge CLOCK_50) begin
if (counter_ping == COUNTER_MAX_PING - 1)
counter_ping <= 25'd0;
else begin
counter_ping <= counter_ping + 25'd1;
end
end
endmodule |