comment utiliser capteur à ultrasons HC-SR04.

 Tout savoir sur le capteur ultrasonique HC-SR04 : principe, branchement et utilisation avec Arduino

 Introduction

Dans le monde de la robotique et de l’électronique embarquée, la mesure de distance joue un rôle essentiel. Que ce soit pour éviter des obstacles, contrôler un niveau d’eau ou créer un système de parking intelligent, le capteur ultrasonique HC-SR04 est un composant incontournable.
Abordable, précis et facile à programmer, il constitue un excellent point de départ pour les étudiants, les enseignants et les passionnés d’Arduino. Cet article vous explique en détail son fonctionnement, ses caractéristiques techniques, ainsi que la méthode pour l’utiliser efficacement dans vos projets.

 1. Présentation du capteur ultrasonique HC-SR04

Le HC-SR04 est un module électronique qui permet de mesurer des distances sans contact, à l’aide d’ondes ultrasonores. Il est constitué de deux éléments ronds en façade :

• un émetteur (transmet des ultrasons à 40 kHz),

• un récepteur (capte le signal réfléchi par un obstacle).

Ce capteur est très populaire dans les projets Arduino, les robots autonomes, ou encore les systèmes de détection automatique.

 2. Les broches du HC-SR04 et leur rôle.

Le module HC-SR04 possède quatre broches principales :

Broche	Nom	Fonction
VCC	Alimentation (5V)	Alimente le capteur
Trig	Trigger	Envoie le signal ultrasonique
Echo	Echo	Reçoit le signal réfléchi
GND	Masse	Relie le capteur à la masse du circuit

Ces quatre connexions suffisent pour faire fonctionner le capteur avec un microcontrôleur tel qu’un Arduino Uno, Nano ou Mega.

 3. Principe de fonctionnement du HC-SR04.

Le principe est simple : le capteur envoie une onde ultrasonique et mesure le temps de trajet de cette onde lorsqu’elle rebondit sur un obstacle.

1. La broche Trig envoie une impulsion de 10 microsecondes.

2. Le capteur émet alors une onde à 40 kHz.

3. L’onde se propage, rencontre un objet, puis revient vers le capteur.

4. La broche Echo devient HIGH pendant toute la durée du trajet aller-retour.

5. En mesurant ce temps, on peut calculer la distance grâce à la formule suivante :

$$\texte{Distance (cm)} = \frac{\texte{Durée (µs)} \times 0.0343}{2}$$

Cette formule repose sur la vitesse du son (343 m/s). La division par deux permet de ne mesurer que la distance aller.

 4. Schéma de branchement avec Arduino

Voici un exemple de câblage typique :

HC-SR04	Arduino
VCC	5V
GND	GND
Trig	Broche 9
Echo	Broche 10

Ce montage simple suffit à obtenir une mesure stable. Il est conseillé d’utiliser des câbles courts et une alimentation stable pour éviter les parasites sur le signal Echo.

 5. Exemple de code Arduino

Voici un ce complet pour mesurer la distance et l’afficher dans le moniteur série :

const int trigPin = 9;
const int echoPin = 10;
long duration;
int distance;

void setup() {

  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  Serial.begin(9600);
}

void loop() {
  // Envoi d'une impulsion de 10 µs

  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);

  // Lecture du temps de retour
  duration = pulseIn(echoPin, HIGH);

  // Calcul de la distance

  distance = duration * 0.0343 / 2;

  Serial.print("Distance : ");
  Serial.print(distance);
  Serial.println(" cm");

  delay(500);
}

Ce programme mesure la distance toutes les demi-secondes et l’affiche dans le moniteur série Arduino.
Vous pouvez ensuite adapter ce code pour allumer une LED, déplacer un servomoteur ou déclencher une alarme selon la distance détectée.

 6. Caractéristiques techniques du capteur HC-SR04

Caractéristique	Valeur
Tension d’alimentation	5V DC
Courant typique	15 mA
Fréquence ultrasonique	40 kHz
Portée de mesure	2 cm à 400 cm
Précision	±3 mm
Angle de détection	environ 15°
Temps de réponse	10 ms environ

Grâce à ces caractéristiques, le HC-SR04 peut être utilisé dans une grande variété de situations, de la simple détection d’obstacle à la mesure de niveau dans un réservoir.

 7. Applications pratiques

Le capteur ultrasonique HC-SR04 trouve sa place dans de nombreux projets :

• Robot éviteur d’obstacles : un robot mobile qui change de direction lorsqu’un mur est détecté.

• Système de parking intelligent : mesure la distance entre la voiture et un mur.

• Télémètre numérique : affiche la distance sur un écran LCD.

• Détecteur de niveau d’eau : contrôle automatiquement le remplissage d’un réservoir.

• Domotique : détection de mouvement ou d’occupation d’une pièce.

Ces applications démontrent la polyvalence et la simplicité d’utilisation de ce capteur dans l’apprentissage et les projets concrets.

 8. Conseils pour de meilleures mesures

• Évitez les surfaces trop fines ou absorbantes (le son ne rebondit pas bien).

• Placez le capteur perpendiculairement à la surface à mesurer.

• Gardez une distance minimale de 2 cm pour éviter les erreurs.

• Si vous travaillez dans un environnement bruyant, ajoutez un filtrage logiciel (moyenne de plusieurs mesures).

• Protégez le capteur de l’humidité et des vibrations excessives.

Ces bonnes pratiques garantissent une mesure stable et fiable, même dans des conditions difficiles.

 9. Comparaison avec d’autres capteurs de distance

Capteur	Technologie	Portée	Précision	Prix
HC-SR04	Ultrasonique	2–400 cm	±3 mm	Très faible
GP2Y0A21	Infrarouge	10–80 cm	±1 cm	Moyen
VL53L0X	Laser (ToF)	2–200 cm	±2 mm	Élevé

Le HC-SR04 reste le meilleur choix pour les projets éducatifs et hobbyistes grâce à son excellent rapport qualité/prix et sa simplicité.

 10. Conclusion

Le capteur ultrasonique HC-SR04 est un outil essentiel pour quiconque s’intéresse à la robotique ou à la mesure de distance. Simple à utiliser, précis et économique, il permet de réaliser des projets variés : robot autonome, station de mesure, système de sécurité ou application domotique.

En l’associant à une carte Arduino, il devient un excellent support d’apprentissage pour découvrir la programmation, les capteurs et les bases de l’électronique.
Son efficacité et sa fiabilité en font un composant indispensable dans le monde des makers, des étudiants et des professeurs de technologie.

capteur ultrasonique avec Arduino

 Dans ce projet, nous utiliserons un capteur à ultrasons pour détecter un intrus.

Ce projet est polyvalent et peut être utilisé et adapté de diverses manières. Le capteur à ultrasons pouvant définir la distance, vous pouvez, par exemple, l'utiliser pour définir une zone et déclencher une 

alarme en cas de franchissement de ce périmètre.

 Le capteur fonctionne comme un radar : il émet un signal ultrasonore, ou ping. Lorsque ce signal touche un objet, il rebondit comme un écho, et le temps entre le ping et l'écho est utilisé pour calculer la distance. 

L'Arduino peut utiliser ce calcul po déclencher un événement, en fonction de la valeur reçue. Dans ce projet, lorsque le capteur détecte un intrus dans un périmètre prédéfini, la LED rouge .

Pour une utilisation plus conviviale, vous pouvez régler la distance très près de vous, de sorte que lorsque vous passez la main devant le capteur.

Insérez le capteur à ultrasons dans la plaque d'essai. Le capteur que nous utilisons dans ce projet possède quatre broches.

Connectez la masse(GND) du capteur au rail de masse de l'Arduino, la tension VCC au +5 V de l'Arduino, 

la tension Trig à la broche 12 de l'Arduino et la tension Echo à la broche 13 de l'Arduino.

 

VCC===5Volt

GND===Masse

TRIG===transmetteur

Echo====récepteur

 le code

#include <NewPing.h> 

#define trigPin 12 

#define echoPin 13 

#define MAX_DISTANCE 500

NewPing sonar(trigPin, echoPin, MAX_DISTANCE); // Library setting

 redLed = 2; /

void setup() {

Serial.begin (9600);

pinMode(trigPin, OUTPUT);

pinMode(echoPin, INPUT);

pinMode(redLed, OUTPUT);

}

void loop() {

int duration, distance, pos = 0, i;

digitalWrite(trigPin, LOW);

delayMicroseconds(2);

digitalWrite(trigPin, HIGH); /

delayMicroseconds(10);

digitalWrite(trigPin, LOW);

duration = pulseIn(echoPin, HIGH); 

distance = (duration / 2) / 29.1;

Serial.print(distance); Serial.println(" cm");

if (distance <= 15) {

 

digitalWrite(redLed, HIGH);

 delay(450); 

digitalWrite(redLed, HIGH); 

 

delay(450); 

digitalWrite(redLed, LOW);

}

else {

digitalWrite(redLed, LOW);

} delay(450);

}

capteur de température avec Arduino

 capteur de température TMP36,

Si les interrupteurs et les boutons sont géniaux, le monde physique ne se résume pas à la simple marche/arrêt. Bien que l'Arduino soit un outil numérique, il peut obtenir des informations de capteurs analogiques pour mesurer des paramètres tels que la température ou la lumière. Pour ce faire, vous utiliserez le convertisseur analogique numérique (CAN) intégré à l'Arduino.

Les broches d'entrée analogique A0 à A5 peuvent renvoyer une valeur comprise entre 0 et 1023, ce qui correspond à une plage de 0 à 5 volts.

Vous utiliserez un capteur de température pour mesurer la température de votre peau. Ce composant produit une tension variable en fonction de la température détectée. Il possède trois broches : une à la terre, une à l'alimentation et une troisième qui fournit une tension variable à votre Arduino. Dans le schéma de ce projet, vous lirez la sortie du capteur et l'utiliserez pour allumer et éteindre des LED indiquant votre température. Il existe plusieurs modèles de capteurs de température.

Ce modèle, le TMP36, est pratique car il produit une tension qui varie directement proportionnellement à la température en degrés Celsius.

CONSTRUIRE LE CIRCUIT

LE CODE

Une paire de constantes utiles

const int sensorPin = A0;

const float baselineTemp = 20.0;

Les constantes sont similaires aux variables : elles permettent de nommer de manière unique les éléments du programme, mais contrairement aux variables, elles ne peuvent pas être modifiées. Nommez l'entrée analogique pour une référence facile et créez une autre constante nommée pour conserver la température de référence.

Pour chaque 2 degrés au-dessus de cette valeur de référence, une LED s'allume.

Vous avez déjà vu le type de données Integer, utilisé ici pour identifier la broche du capteur. La température est stockée sous forme de nombre à virgule flottante. Ce type de nombre possède une virgule décimale et est utilisé pour les nombres pouvant être exprimés sous forme de fractions.

Initialiser le port série à la vitesse souhaitée

void setup(){

Serial.begin(9600); 

Dans la configuration, vous allez utiliser une nouvelle commande : Serial. begin(). Cela ouvre une connexion entre l'Arduino et l'ordinateur, ce qui vous permet de visualiser les valeurs de l'entrée analogique sur l'écran de votre ordinateur.

L'argument 9600 correspond à la vitesse de communication de l'Arduino, soit 9600 bits par seconde. Vous utiliserez le moniteur série de l'IDE Arduino pour visualiser les informations que vous choisissez d'envoyer depuis votre microcontrôleur. 

Lorsque vous ouvrez le moniteur série de l'IDE, vérifiez que le débit en bauds est de 9600.

Initialiser les directions de la broche numérique et éteindre.

for(int pinNumber = 2; pinNumber<5; pinNumber++){ 

pinMode(pinNumber,OUTPUT); digitalWrite(pinNumber, LOW);

}

 }

Ensuite, une boucle for() permet de définir certaines broches comme sorties. Il s'agit des broches auxquelles vous avez connecté des LED précédemment.

 Au lieu de leur donner des noms uniques et d'utiliser la fonction pinMode() pour chacune d'elles, vous pouvez utiliser une boucle for() pour les parcourir rapidement. 

C'est une astuce pratique si vous souhaitez parcourir un grand nombre d'éléments similaires dans un programme. Indiquez à la boucle for() de parcourir les broches 2 à 4 séquentiellement.

Lire le capteur de température

void loop(){

int sensorVal = analogRead(sensorPin);

Dans la fonction loop(), vous utiliserez une variable locale nommée sensorVal

pour stocker la valeur du capteur. Pour obtenir la valeur du capteur, appelez analogRead() qui prend un argument :

la broche sur laquelle la tension doit être mesurée. La valeur, comprise entre 0 et 1023, représente la tension sur la broche.

Envoyer les valeurs du capteur de température à l'Arduino.

Serial.print(“Sensor Value: “); Serial.print(sensorVal);

La fonction Serial.print() envoie des informations de l'Arduino à un ordinateur connecté. Ces informations sont visibles sur votre écran série. 

Si vous lui donnez un argument entre guillemets, Serial.print() affichera le texte saisi. Si vous lui donnez une variable en argument, elle affichera la valeur de cette variable.

Convertir la mesure du capteur en tension

float voltage = (sensorVal/1024.0) * 5.0;

Avec un peu de mathématiques, il est possible de déterminer la tension réelle sur la broche.

Cette tension est comprise entre 0 et 5 volts et comporte une partie fractionnaire (par exemple, 2,5 volts). Il faut donc la stocker dans un nombre à virgule flottante. Créez une variable nommée voltage pour contenir cette valeur. 

Divisez sensorVal par 1024,0 et multipliez par 5,0. Le nouveau nombre représente la tension sur la broche. Comme pour la valeur du capteur, vous l'afficherez sur le moniteur série.

Convertir la tension en température et envoyer la valeur à l'ordinateur

Serial.print(“, Volts: “); Serial.print(voltage)

Si vous consultez la fiche technique du capteur, vous trouverez des informations sur la plage de tension de sortie. Les fiches techniques sont comme des manuels de composants électroniques.

 Elles sont rédigées par des ingénieurs, pour d'autres ingénieurs. La fiche technique de ce capteur explique que chaque variation de 10 millivolts du capteur équivaut à une variation de température de 1 degré Celsius. Elle indique également que le capteur peut mesurer des températures inférieures à 0 degré.

 De ce fait, vous devrez créer un décalage pour les valeurs inférieures à zéro (0 degré). En prenant la tension, en soustrayant 0,5 et en multipliant par 100, vous obtenez la température exacte en degrés Celsius. 

Enregistrez cette nouvelle valeur dans une variable à virgule flottante appelée température. Maintenant que vous avez la température réelle, imprimez là également sur le moniteur série. Puisque la variable de température est la dernière valeur que vous allez imprimer dans cette boucle, vous allez utiliser une commande légèrement différente : Serial.println(). Cette commande crée une nouvelle ligne dans le moniteur série après l'envoi de la valeur. Cela facilite la lecture lors de l'impression.

Éteindre les LED pour une température basse

Serial.print(“, degrees C: “);

float temperature = (voltage - .5) * 100;

Serial.println(temperature);

if(temperature < baselineTemp){ 

digitalWrite(2, LOW); 

digitalWrite(3, LOW); 

digitalWrite(4, LOW);

Avec la température réelle, vous pouvez configurer une instruction if()...else

pour allumer les LED. En utilisant la température de référence comme point de départ, vous allumerez une LED pour chaque augmentation de température de 2 degrés au-dessus de cette température de référence. Vous rechercherez une plage de valeurs à mesure que vous parcourez l'échelle de température.

}else if(temperature >= baselineTemp+2 &&

temperature < baselineTemp+4){ 

digitalWrite(2, HIGH); 

digitalWrite(3, LOW);

digitalWrite(4, LOW);

}else if(temperature >= baselineTemp+4 && temperature < baselineTemp+6){ 

digitalWrite(2, HIGH);

digitalWrite(3, HIGH);

digitalWrite(4, LOW);

}else if(temperature >= baselineTemp+6){

digitalWrite(2, HIGH); 

digitalWrite(3, HIGH); 

digitalWrite(4, HIGH);

} delay(1)

}

En élargissant les types d'entrées lisibles, vous avez utilisé

analogRead() et le moniteur série pour suivre les changements dans

votre Arduino. Il est désormais possible de lire un grand nombre

de capteurs et d'entrées analogiques.

Arduino et les enfants : Une excellente introduction à l’électronique et à la programmation.

L’Arduino est une plateforme de prototypage électronique open source qui peut être une ressource fantastique pour initier les enfants à l’électronique, à la logique informatique, et à la pensée créative. Voici un aperçu simple et pratique pour comprendre comment Arduino peut être utilisé avec les enfants :

 Pourquoi utiliser Arduino avec les enfants ?

• Ludique : Les projets Arduino sont souvent liés à des objets du quotidien (lumières, moteurs, sons…), ce qui rend l'apprentissage concret et amusant.

• Éducatif : Ils apprennent des bases de programmation (souvent en langage Arduino/C++) et d’électronique (courant, résistance, capteurs…).

• Créatif : Ils peuvent créer des robots, des jeux, des alarmes, des lampes interactives, etc.

• Développement des compétences du XXIe siècle : Pensée logique, résolution de problèmes, travail en équipe.

Ce qu’il faut pour commencer

• Une carte Arduino (Uno est le modèle le plus courant pour débuter)

• Un kit de démarrage contenant :

  • LEDs, résistances, capteurs, petits moteurs, câbles, etc.

  • Un câble USB pour connecter la carte à l’ordinateur

• Un ordinateur avec le logiciel Arduino IDE

• Des tutoriels adaptés à l’âge de l’enfant

À partir de quel âge ?

• 7–9 ans : Avec accompagnement adulte. Utilisation d’environnements simplifiés comme Tinkercad Circuits ou Blocklyduino (programmation par blocs).

• 10–13 ans : Peuvent commencer à taper du vrai code Arduino avec un peu d’aide.

• 14 ans et + : Autonomie croissante sur des projets complexes (robotique, domotique, etc.).

Exemples de projets pour enfants

1. Faire clignoter une LED (Hello World de l’Arduino)

2. Un feu tricolore automatique

3. Un thermomètre avec affichage

4. Un capteur de mouvement avec alarme

5. Un mini robot éviter d'obstacles

6. Un piano avec des boutons et un buzzer

Conseils pour une bonne expérience

• Commencer par des projets très simples.

• Utiliser des visuels (diagrammes de montage, vidéos).

• Faire en sorte que l’enfant comprenne le "pourquoi" et pas juste le "comment".

• Laisser place à l’expérimentation et à l’échec : c’est aussi un apprentissage !

Ressources utiles

• Tinkercad Circuits (simulation sans matériel réel)

• Blocklyduino / Ardublock (programmation par blocs)

• Livres et kits adaptés aux enfants : ex. "Arduino pour les enfants", "Inventer avec Arduino Junior"

• YouTube : chaînes pédagogiques comme "Mini Maker", "Technozone51", etc.

The relationship between Arduino and Artificial Intelligence (AI)

 

The relationship between Arduino and Artificial Intelligence (AI) has become increasingly important as smart embedded systems become more common. Here's how they relate:

---

🔌 1. Arduino as a Data Collector for AI

Arduino boards (like Uno, Nano, or ESP32) are often used to gather real-world data from sensors:

• Examples:

  • Temperature, humidity, or gas sensors

  • Light, motion, and distance sensors

  • Audio and image (via external modules)

🧠 The data collected can then be:

• Sent to a more powerful system (e.g., Raspberry Pi, PC, or cloud) to be processed with AI models.

• Used to train models for later use or make real-time decisions.

---

🤖 2. Arduino Running Lightweight AI Models

Some optimized or quantized AI models can be deployed directly on microcontrollers:

• Platforms and Tools:

  • TinyML (Tiny Machine Learning) → Run ML models on microcontrollers

  • TensorFlow Lite for Microcontrollers (TFLM)

  • Edge Impulse → Cloud-based tool to train and deploy models on microcontrollers

• Examples:

  • Voice command recognition ("yes", "no")

  • Gesture recognition with accelerometers

  • Anomaly detection in machines

📍Boards that support AI better:

• Arduino Nano 33 BLE Sense

• ESP32 (with enough RAM and processing speed)

---

🌐 3. Arduino as an Interface for AI Systems

Arduino can also be the “actuator” or interface for an AI system running elsewhere:

• AI runs on a PC/cloud and sends commands to Arduino to control:

  • Motors (robot arms)

  • Lights, buzzers, displays

  • Home automation (IoT)

---

💡 Example Projects

• Smart fan that turns on/off based on temperature + voice commands

• Plant watering system using moisture sensors + predictive models

• Facial recognition system where Arduino controls access based on camera + AI model results

Veilleuse activée par la lumière avec Arduino.

 Ce projet est un test simple du fonctionnement d'une photorésistance : nous allons créer une veilleuse dont la luminosité augmente en fonction de la quantité de lumière détectée.

PIÈCES NÉCESSAIRES

Carte Arduino

Plaque d'expérimentation

Câbles de connexion

Photorésistance

LED

Résistance de 10 kOhms

FONCTIONNEMENT

Une photorésistance est une résistance variable qui réagit à la lumière ; moins elle est éclairée, plus sa résistance est élevée. Cette valeur de résistance fait varier la tension envoyée à la broche d'entrée de l'Arduino, qui à son tour envoie cette tension à la broche de sortie, qui correspond au niveau de puissance de la LED. Ainsi, en cas de faible luminosité, la LED brille. Il existe différents types de photorésistances, mais elles ont généralement une petite tête ovale transparente avec des lignes ondulées (cette photo  ).

Les photorésistances n'ont pas de polarité ; le sens de connexion des pattes importe donc peu.

Le principe est similaire à celui d'une veilleuse pour enfant.

Une photorésistance peut contrôler bien plus que des LED, comme nous le verrons dans les chapitres suivants. Comme nous n'avons que deux connexions d'alimentation et de masse, nous n'utiliserons pas les rails d'alimentation de la platine d'expérimentation.

CONSTRUCTION

1. Placez votre photorésistance sur la plaque d'essai, en connectant une patte à la masse (GND) de l'Arduino et l'autre patte à l'Arduino A0.

2. Connectez une patte de la résistance de 10 kOhms au +5 V et l'autre patte à la patte de la photorésistance A0, comme illustré sur le schéma .

3. Insérez la patte positive la plus longue de la LED directement dans la broche 13 de l'Arduino et la patte négative la plus courte directement dans la masse de l'Arduino. Nous utiliserions normalement une résistance pour limiter le courant d'une LED, mais nous n'en avons pas besoin ici, car la broche 13 de l'Arduino en possède une intégrée.

4. Téléchargez le code dans le « Schéma » ci-dessous.

LE CROQUIS

Le croquis connecte d'abord la photorésistance à la broche A0 de l'Arduino (ENTRÉE)

et la LED à la broche 13 (SORTIE). Nous établissons la communication série avec 

Serial.begin(9600), qui (une fois votre Arduino connecté à votre PC) enverra des informations au moniteur série de l'Arduino. Ainsi, la valeur de résistance de la photorésistance s'affichera sur le moniteur série de votre ordinateur, comme illustré .

La boucle lit la valeur analogique de la photorésistance et la transmet à la LED sous forme de tension. La broche A0 peut lire 1 024 valeurs, ce qui signifie qu'il existe 1 024 niveaux de luminosité possibles pour la LED. Les variations infimes entre ces niveaux sont peu visibles ; nous divisons donc ce nombre par 4 pour le réduire à seulement 256 valeurs, ce qui facilite la détection des variations de tension de la LED.

int lightPin = A0; 

int ledPin = 13; 

void setup() {

Serial.begin(9600); /

pinMode(ledPin, OUTPUT); 

}

void loop() {

 Serial.println(analogRead(lightPin));

 analogWrite(ledPin, analogRead(lightPin) / 4);

delay(10);