Construire un Système Radar Arduino avec Capteur Ultrasonique et Servo - Guide Étape par Étape

Dans ce tutoriel Arduino, je vais vous montrer comment réaliser ce radar au look cool en utilisant la carte Arduino et l'environnement de développement Processing. Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous pour plus de détails.

Vue d'Ensemble

Pour ce projet Arduino, vous avez besoin d'un capteur ultrasonique pour détecter les objets, d'un petit servomoteur de modélisme pour faire pivoter le capteur et d'une carte Arduino pour les contrôler.

Composants Nécessaires pour ce Projet Arduino

Vous pouvez vous procurer ces composants sur l'un des sites ci-dessous :

• Capteur Ultrasonique HC-SR04
• Servomoteur
• Carte Arduino
• Plaque d'essai et fils de connexion

Construction de l'Appareil

• D'abord, j'ai fabriqué un support en carton pour connecter le capteur ultrasonique au servomoteur. Je l'ai plié comme montré sur l'image ci-dessous, collé et fixé au servomoteur à l'aide d'une vis.

• J'ai aussi fixé un connecteur à broches sur lequel j'ai soudé 4 fils de connexion pour le capteur.

• Enfin, j'ai fixé le servomoteur à la carte Arduino à l'aide d'un élastique.

Il existe aussi des supports de fixation spéciaux pour le capteur ultrasonique chez Banggood. Vous pouvez les trouver aux liens suivants :

• Capteur Ultrasonique avec Support de Fixation
• Support de Fixation pour Capteur Ultrasonique Banggood

Schéma de Câblage du Radar Arduino

J'ai connecté le capteur ultrasonique HC-SR04 aux broches 10 et 11 et le servomoteur à la broche 12 de la carte Arduino.

Codes Sources

Maintenant, nous devons créer un code et le téléverser sur la carte Arduino pour permettre l'interaction entre l'Arduino et l'IDE Processing. Pour comprendre comment la connexion fonctionne, consultez mon tutoriel Arduino et Processing.

Voici le Code Source Arduino avec description de chaque ligne :

// Inclut la bibliothèque Servo
#include 
// Définit les broches Trig et Echo du capteur ultrasonique
const int trigPin = 10;
const int echoPin = 11;
// Variables pour la durée et la distance
long duration;
int distance;
Servo myServo; // Crée un objet servo pour contrôler le moteur

void setup() {
  pinMode(trigPin, OUTPUT); // TrigPin en sortie
  pinMode(echoPin, INPUT);  // EchoPin en entrée
  Serial.begin(9600);
  myServo.attach(12); // Broche du servomoteur
}

void loop() {
  // Rotation du servomoteur de 15 à 165 degrés
  for(int i = 15; i <= 165; i++) {
    myServo.write(i);
    delay(30);
    distance = calculateDistance(); // Calcule la distance pour chaque degré
    Serial.print(i); // Envoie l'angle actuel
    Serial.print(","); // Caractère de séparation pour indexation dans Processing
    Serial.print(distance); // Envoie la distance
    Serial.print("."); // Caractère de fin pour indexation
  }
  // Répète de 165 à 15 degrés
  for(int i = 165; i > 15; i--) {
    myServo.write(i);
    delay(30);
    distance = calculateDistance();
    Serial.print(i);
    Serial.print(",");
    Serial.print(distance);
    Serial.print(".");
  }
}

// Fonction de calcul de la distance mesurée par le capteur ultrasonique
int calculateDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  // Met trigPin à HIGH pendant 10 microsecondes
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH); // Lit echoPin, temps de parcours en µs
  distance = duration * 0.034 / 2; // Conversion en cm
  return distance;
}

Maintenant, nous allons recevoir les valeurs d'angle et de distance mesurées par le capteur depuis la carte Arduino dans l'IDE Processing en utilisant la fonction SerialEvent() qui lit les données du port série et nous mettrons les valeurs de l'angle et de la distance dans les variables iAngle et iDistance. Ces variables seront utilisées pour dessiner le radar, les lignes, les objets détectés et du texte.

Pour dessiner le radar, j'ai créé la fonction drawRadar() qui utilise les fonctions arc() et line().

void drawRadar() {
  pushMatrix();
  translate(960, 1000); // Déplace l'origine des coordonnées
  noFill();
  strokeWeight(2);
  stroke(98, 245, 31); // Couleur verte
  // Dessine les arcs
  arc(0, 0, 1800, 1800, PI, TWO_PI);
  arc(0, 0, 1400, 1400, PI, TWO_PI);
  arc(0, 0, 1000, 1000, PI, TWO_PI);
  arc(0, 0, 600, 600, PI, TWO_PI);
  // Dessine les lignes d'angle
  line(-960, 0, 960, 0);
  line(0, 0, -960*cos(radians(30)), -960*sin(radians(30)));
  line(0, 0, -960*cos(radians(60)), -960*sin(radians(60)));
  line(0, 0, -960*cos(radians(90)), -960*sin(radians(90)));
  line(0, 0, -960*cos(radians(120)), -960*sin(radians(120)));
  line(0, 0, -960*cos(radians(150)), -960*sin(radians(150)));
  line(-960*cos(radians(30)), 0, 960, 0);
  popMatrix();
}

Pour dessiner la ligne qui bouge le long du radar, j'ai créé la fonction drawLine(). Son centre de rotation est défini avec translate() et en utilisant line() avec la variable iAngle, la ligne est redessinée pour chaque degré.

void drawLine() {
  pushMatrix();
  strokeWeight(9);
  stroke(30, 250, 60);
  translate(960, 1000);
  line(0, 0, 950*cos(radians(iAngle)), -950*sin(radians(iAngle)));
  popMatrix();
}

Pour dessiner les objets détectés, j'ai créé la fonction drawObject(). Elle récupère la distance du capteur ultrasonique, la convertit en pixels et, en combinaison avec l'angle du capteur, dessine l'objet sur le radar.

void drawObject() {
  pushMatrix();
  translate(960, 1000);
  strokeWeight(9);
  stroke(255, 10, 10); // Couleur rouge
  pixsDistance = iDistance * 22.5; // Conversion cm vers pixels
  // Limite la portée à 40 cm
  if(iDistance < 40) {
    line(pixsDistance*cos(radians(iAngle)), -pixsDistance*sin(radians(iAngle)),
         950*cos(radians(iAngle)), -950*sin(radians(iAngle)));
  }
  popMatrix();
}

Pour le texte à l'écran, j'ai créé la fonction drawText() qui affiche du texte à des positions précises.

Toutes ces fonctions sont appelées dans la fonction principale draw() qui se répète en continu et dessine l'écran. J'utilise aussi la fonction fill() avec 2 paramètres pour simuler le flou de mouvement et l'estompage progressif de la ligne en mouvement.

void draw() {
  fill(98, 245, 31);
  textFont(orcFont);
  // Simulation flou de mouvement et estompage lent
  noStroke();
  fill(0, 4);
  rect(0, 0, width, 1010);
  fill(98, 245, 31); // Vert
  // Appel des fonctions de dessin
  drawRadar();
  drawLine();
  drawObject();
  drawText();
}

Voici l'apparence finale du radar :

Voici le code source complet Processing du Radar Arduino :

import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
Serial myPort;
String angle = "";
String distance = "";
String data = "";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1 = 0;
int index2 = 0;
PFont orcFont;

void setup() {
  size(1920, 1080);
  smooth();
  myPort = new Serial(this, "COM4", 9600);
  myPort.bufferUntil('.');
  orcFont = loadFont("OCRAExtended-30.vlw");
}

void draw() {
  fill(98, 245, 31);
  textFont(orcFont);
  noStroke();
  fill(0, 4);
  rect(0, 0, width, 1010);
  fill(98, 245, 31);
  drawRadar();
  drawLine();
  drawObject();
  drawText();
}

void serialEvent(Serial myPort) {
  data = myPort.readStringUntil('.');
  data = data.substring(0, data.length()-1);
  index1 = data.indexOf(",");
  angle = data.substring(0, index1);
  distance = data.substring(index1+1, data.length());
  iAngle = int(angle);
  iDistance = int(distance);
}

void drawRadar() {
  pushMatrix();
  translate(960, 1000);
  noFill();
  strokeWeight(2);
  stroke(98, 245, 31);
  arc(0, 0, 1800, 1800, PI, TWO_PI);
  arc(0, 0, 1400, 1400, PI, TWO_PI);
  arc(0, 0, 1000, 1000, PI, TWO_PI);
  arc(0, 0, 600, 600, PI, TWO_PI);
  line(-960, 0, 960, 0);
  line(0, 0, -960*cos(radians(30)), -960*sin(radians(30)));
  line(0, 0, -960*cos(radians(60)), -960*sin(radians(60)));
  line(0, 0, -960*cos(radians(90)), -960*sin(radians(90)));
  line(0, 0, -960*cos(radians(120)), -960*sin(radians(120)));
  line(0, 0, -960*cos(radians(150)), -960*sin(radians(150)));
  line(-960*cos(radians(30)), 0, 960, 0);
  popMatrix();
}

void drawObject() {
  pushMatrix();
  translate(960, 1000);
  strokeWeight(9);
  stroke(255, 10, 10);
  pixsDistance = iDistance * 22.5;
  if(iDistance < 40) {
    line(pixsDistance*cos(radians(iAngle)), -pixsDistance*sin(radians(iAngle)),
         950*cos(radians(iAngle)), -950*sin(radians(iAngle)));
  }
  popMatrix();
}

void drawLine() {
  pushMatrix();
  strokeWeight(9);
  stroke(30, 250, 60);
  translate(960, 1000);
  line(0, 0, 950*cos(radians(iAngle)), -950*sin(radians(iAngle)));
  popMatrix();
}

void drawText() {
  pushMatrix();
  if(iDistance > 40) {
    noObject = "Out of Range";
  } else {
    noObject = "In Range";
  }
  fill(0, 0, 0);
  noStroke();
  rect(0, 1010, width, 1080);
  fill(98, 245, 31);
  textSize(25);
  text("10cm", 1180, 990);
  text("20cm", 1380, 990);
  text("30cm", 1580, 990);
  text("40cm", 1780, 990);
  textSize(40);
  text("Objet: " + noObject, 240, 1050);
  text("Angle: " + iAngle + " °", 1050, 1050);
  text("Distance: ", 1380, 1050);
  if(iDistance < 40) {
    text(" " + iDistance + " cm", 1400, 1050);
  }
  textSize(25);
  fill(98, 245, 60);
  translate(961+960*cos(radians(30)), 982-960*sin(radians(30)));
  rotate(-radians(-60));
  text("30°", 0, 0);
  resetMatrix();
  translate(954+960*cos(radians(60)), 984-960*sin(radians(60)));
  rotate(-radians(-30));
  text("60°", 0, 0);
  resetMatrix();
  translate(945+960*cos(radians(90)), 990-960*sin(radians(90)));
  rotate(radians(0));
  text("90°", 0, 0);
  resetMatrix();
  translate(935+960*cos(radians(120)), 1003-960*sin(radians(120)));
  rotate(radians(-30));
  text("120°", 0, 0);
  resetMatrix();
  translate(940+960*cos(radians(150)), 1018-960*sin(radians(150)));
  rotate(radians(-60));
  text("150°", 0, 0);
  popMatrix();
}

Nouvelle Version Mise à Jour du Code Radar Arduino pour S'Adapter à Toute Résolution d'Écran :

Il suffit de changer les valeurs dans la fonction size() avec votre résolution d'écran.

/* Projet Radar Arduino
 * Version mise à jour. S'adapte à toute résolution d'écran !
 * Changez juste les valeurs dans size() avec votre résolution.
 * par Dejan Nedelkovski,
 * www.HowToMechatronics.com
 */
import processing.serial.*;
import java.awt.event.KeyEvent;
import java.io.IOException;
Serial myPort;
String angle = "";
String distance = "";
String data = "";
String noObject;
float pixsDistance;
int iAngle, iDistance;
int index1 = 0;
int index2 = 0;
PFont orcFont;

void setup() {
  size(1920, 1080); // ***MODIFIEZ POUR VOTRE RÉSOLUTION***
  smooth();
  myPort = new Serial(this, "COM4", 9600);
  myPort.bufferUntil('.');
  orcFont = loadFont("OCRAExtended-30.vlw");
}

void draw() {
  fill(98, 245, 31);
  textFont(orcFont);
  noStroke();
  fill(0, 4);
  rect(0, 0, width, height-height*0.065);
  fill(98, 245, 31);
  drawRadar();
  drawLine();
  drawObject();
  drawText();
}

void serialEvent(Serial myPort) {
  data = myPort.readStringUntil('.');
  data = data.substring(0, data.length()-1);
  index1 = data.indexOf(",");
  angle = data.substring(0, index1);
  distance = data.substring(index1+1, data.length());
  iAngle = int(angle);
  iDistance = int(distance);
}

void drawRadar() {
  pushMatrix();
  translate(width/2, height-height*0.074);
  noFill();
  strokeWeight(2);
  stroke(98, 245, 31);
  arc(0, 0, (width-width*0.0625), (width-width*0.0625), PI, TWO_PI);
  arc(0, 0, (width-width*0.27), (width-width*0.27), PI, TWO_PI);
  arc(0, 0, (width-width*0.479), (width-width*0.479), PI, TWO_PI);
  arc(0, 0, (width-width*0.687), (width-width*0.687), PI, TWO_PI);
  line(-width/2, 0, width/2, 0);
  line(0, 0, (-width/2)*cos(radians(30)), (-width/2)*sin(radians(30)));
  line(0, 0, (-width/2)*cos(radians(60)), (-width/2)*sin(radians(60)));
  line(0, 0, (-width/2)*cos(radians(90)), (-width/2)*sin(radians(90)));
  line(0, 0, (-width/2)*cos(radians(120)), (-width/2)*sin(radians(120)));
  line(0, 0, (-width/2)*cos(radians(150)), (-width/2)*sin(radians(150)));
  line((-width/2)*cos(radians(30)), 0, width/2, 0);
  popMatrix();
}

void drawObject() {
  pushMatrix();
  translate(width/2, height-height*0.074);
  strokeWeight(9);
  stroke(255, 10, 10);
  pixsDistance = iDistance * ((height-height*0.1666)*0.025);
  if(iDistance < 40) {
    line(pixsDistance*cos(radians(iAngle)), -pixsDistance*sin(radians(iAngle)),
         (width-width*0.505)*cos(radians(iAngle)), -(width-width*0.505)*sin(radians(iAngle)));
  }
  popMatrix();
}

void drawLine() {
  pushMatrix();
  strokeWeight(9);
  stroke(30, 250, 60);
  translate(width/2, height-height*0.074);
  line(0, 0, (height-height*0.12)*cos(radians(iAngle)), -(height-height*0.12)*sin(radians(iAngle)));
  popMatrix();
}

void drawText() {
  pushMatrix();
  if(iDistance > 40) {
    noObject = "Out of Range";
  } else {
    noObject = "In Range";
  }
  fill(0, 0, 0);
  noStroke();
  rect(0, height-height*0.0648, width, height);
  fill(98, 245, 31);
  textSize(25);
  text("10cm", width-width*0.3854, height-height*0.0833);
  text("20cm", width-width*0.281, height-height*0.0833);
  text("30cm", width-width*0.177, height-height*0.0833);
  text("40cm", width-width*0.0729, height-height*0.0833);
  textSize(40);
  text("Objet: " + noObject, width-width*0.875, height-height*0.0277);
  text("Angle: " + iAngle + " °", width-width*0.48, height-height*0.0277);
  text("Distance: ", width-width*0.26, height-height*0.0277);
  if(iDistance < 40) {
    text(" " + iDistance + " cm", width-width*0.225, height-height*0.0277);
  }
  textSize(25);
  fill(98, 245, 60);
  translate((width-width*0.4994)+width/2*cos(radians(30)), (height-height*0.0907)-width/2*sin(radians(30)));
  rotate(-radians(-60));
  text("30°", 0, 0);
  resetMatrix();
  translate((width-width*0.503)+width/2*cos(radians(60)), (height-height*0.0888)-width/2*sin(radians(60)));
  rotate(-radians(-30));
  text("60°", 0, 0);
  resetMatrix();
  translate((width-width*0.507)+width/2*cos(radians(90)), (height-height*0.0833)-width/2*sin(radians(90)));
  rotate(radians(0));
  text("90°", 0, 0);
  resetMatrix();
  translate(width-width*0.513+width/2*cos(radians(120)), (height-height*0.07129)-width/2*sin(radians(120)));
  rotate(radians(-30));
  text("120°", 0, 0);
  resetMatrix();
  translate((width-width*0.5104)+width/2*cos(radians(150)), (height-height*0.0574)-width/2*sin(radians(150)));
  rotate(radians(-60));
  text("150°", 0, 0);
  popMatrix();
}