Servomoteur avec Arduino.

 

Qu’est-ce qu’un servo-moteur ?

introduction.

Un servo-moteur est un petit moteur capable de tourner avec précision dans un angle défini, généralement entre 0° et 180°.
Contrairement à un moteur DC qui tourne librement, un servo se positionne exactement là où on lui dit.

Composition d’un servo

Un servo-moteur contient :

• Un moteur DC

• Un circuit électronique interne

• Un système d’engrenages

• Un potentiomètre qui mesure l’angle réel

Grâce à cela, le servo compare l’angle demandé à l’angle réel et ajuste en permanence → c’est un système à rétroaction (feedback).

Les fils du servo-moteur.

Couleur du fil	Fonction
🔴 Rouge	+5V (alimentation)
⚫ Noir/Marron	GND (masse)
🟠 Jaune/Orange	Signal (commande Arduino)

Comment fonctionne le signal du servo ? (PWM)

Le servo reçoit un signal appelé PWM :

• Une impulsion de 1 ms → angle ≈ 0°

• 1.5 ms → 90°

• 2 ms → 180°

Ce signal est envoyé toutes les 20 ms (50 Hz).

Branchement du servo avec Arduino.

Servo	Arduino
Rouge	5V
Noir	GND
Orange	Pin 9 (par ex.)

 Le servo doit avoir une bonne alimentation (certains demandent 500 mA).

Code Arduino simple pour contrôler un servo

#include <Servo.h>

Servo monServo;

void setup() {
  monServo.attach(9);  // pin du servo
}

void loop() {
  monServo.write(0);   // va à 0°
  delay(1000);


  monServo.write(90);  // va à 90°
  delay(1000);

  monServo.write(180); // va à 180°
  delay(1000);
}

Applications du servo-moteur

✓ Robotique (bras robotique)
✓ Voitures télécommandées (direction)
✓ Robots suiveurs
✓ Radar Arduino + HC-SR04
✓ Mécanismes ouvrants (portes, trappes…)

Conclusion

Le servo-moteur est un composant essentiel en robotique, en modélisme et dans les projets Arduino. Grâce à son contrôle précis de l’angle, il permet de réaliser des mouvements fiables, rapides et répétables. Son fonctionnement repose sur un signal PWM qui lui indique la position exacte à atteindre.

Facile à utiliser, même pour les débutants, le servo-moteur est idéal pour créer des systèmes interactifs : bras robotisés, roues directrices, capteurs mobiles, portes automatiques, etc. Compact, peu coûteux et très précis, il reste l’un des moteurs les plus adaptés aux projets éducatifs et aux prototypes.

En résumé, le servo-moteur combine simplicité, précision et polyvalence, ce qui en fait un élément incontournable pour apprendre et réaliser des projets mécaniques et électroniques.

Apprendre les Listes avec Turtle Python.

 

1. Introduction

Le module turtle de Python permet de créer des graphiques et animations via un concept simple de "tortue graphique". L'utilisation des listes Python dans ce contexte permet de gérer dynamiquement les couleurs, positions, tailles, formes et d'automatiser des motifs complexes.

Objectifs

• Maîtriser la création et manipulation de listes.

• Utiliser des listes pour générer des dessins programmatiques.

• Combiner boucles et listes pour créer des animations avancées.

2. Rappel des bases sur les listes

# Création d'une liste

fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]

# Accès aux éléments

print(fruits[0])   # 'pomme'
print(nombres[-1]) # 5

# Modification

fruits[1] = "kiwi"

# Ajouter / supprimer

fruits.append("mangue")
fruits.remove("orange")

# Parcourir

for fruit in fruits:
    print(fruit)

Points clés avancés

• Slicing, index négatif, compréhension de liste.

• Combinaison avec boucles et conditions.

3. Intégration des listes avec Turtle Python

3.1 Listes de couleurs

import turtle

t = turtle.Turtle()
couleurs = ["red", "green", "blue", "orange", "purple"]

for couleur in couleurs:
    t.color(couleur)
    t.forward(100)
    t.right(72)

Utilisation d'une liste pour appliquer dynamiquement les couleurs à chaque segment.

3.2 Listes de positions (coordonnées)

positions = [(0,0), (100,0), (100,100), (0,100)]
for x, y in positions:
    t.goto(x, y)

Chaque point de la liste est visité pour dessiner un polygone précis.

3.3 Listes de formes et tailles.

formes = ["turtle", "circle", "square"]
t.shapesize(2)
for f in formes:
    t.shape(f)
    t.stamp()
    t.forward(60)

Les formes sont extraites d'une liste et imprimées sur l'écran.

4. Combiner Listes et Boucles pour Motifs Complexes

import turtle

t = turtle.Turtle()
t.speed(0)
couleurs = ["red", "orange", "yellow", "green", "blue", "purple"]

for i in range(36):
    t.color(couleurs[i % len(couleurs)])
    t.circle(100)
    t.right(10)

Création d'un motif circulaire avec rotation et changement de couleur.

5. Exemple Avancé : Fleur Multicolore

import turtle

t = turtle.Turtle()
t.speed(0)
couleurs = ["red", "yellow", "blue", "green", "orange", "purple"]

for couleur in couleurs:
    t.color(couleur)
    for i in range(36):
        t.forward(100)
        t.right(170)
    t.right(60)

t.hideturtle()
turtle.done()

Combinaison de deux boucles imbriquées et d'une liste de couleurs pour générer un motif complexe et esthétique.

6. Concepts Avancés à Retenir

• Indexation et slicing pour gérer les listes de manière dynamique.

• Listes imbriquées pour coordonnées 2D ou 3D.

• Compréhension de liste pour générer des séries de valeurs (ex. couleurs ou longueurs).

• Combinaison listes + boucles pour automatiser des motifs répétitifs ou animations.

• Utilisation de modulo (i % len(liste)) pour boucler sur des listes plus courtes que le nombre de répétitions.

7. Exercices Professionnels

1. Créer un motif étoilé avec 8 branches et une liste de couleurs dynamique.

2. Dessiner une spirale de carrés où chaque carré utilise une couleur de liste différente.

3. Générer une grille 2D de cercles avec des tailles et couleurs stockées dans deux listes différentes.

4. Combiner positions, couleurs et formes pour créer un logo abstrait.

8. Conclusion

L'association des listes Python et du module Turtle permet de créer des dessins et animations programmatiques complexes. La maîtrise de ces techniques est essentielle pour la programmation graphique, l'algorithmique visuelle et la création de projets interactifs.

Guide complet du fonctionnement Servo-moteur avec Arduino .

Servo-moteur avec Arduino : Guide complet du fonctionnement, du branchement et de la programmation.

Introduction

Le servo-moteur est l’un des composants les plus polyvalents et indispensables dans les projets Arduino, la robotique éducative et le modélisme. Contrairement à un moteur classique, il permet de contrôler très précisément la position d’un axe dans un angle donné, généralement entre 0° et 180°. Cette capacité de rotation limitée mais ultraprécise rend le servo idéal pour une multitude d’applications telles que les bras robotisés, les systèmes de visée, les véhicules radiocommandés, les mécanismes automatisés et les capteurs orientables.

Son fonctionnement accessible, son faible coût et sa grande disponibilité en font un excellent choix pour les débutants, tout en étant suffisamment performant pour répondre aux besoins de projets plus avancés. Dans cet article, nous allons explorer en profondeur ce qu’est un servo-moteur, comment il fonctionne, comment le connecter correctement à une carte Arduino et comment le programmer pour obtenir des mouvements précis et reproductibles.

1. Qu’est-ce qu’un servo-moteur ?

Un servo-moteur, souvent appelé « servo », est un dispositif électromécanique conçu pour effectuer des rotations contrôlées. Contrairement à un moteur à courant continu, il n’effectue pas de rotation libre : sa position est gérée par un système interne intelligent.

Un servo est composé de trois éléments principaux :

• Un réducteur

Ce système d’engrenages réduit la vitesse du moteur tout en augmentant son couple, permettant au servo de déplacer des charges avec précision.

• Un circuit de contrôle interne

C’est lui qui interprète les signaux envoyés par l’Arduino. Le circuit compare l’angle demandé avec l’angle réel et ajuste automatiquement la position du moteur pour obtenir le mouvement souhaité.

• Un capteur de position (potentiomètre)

Il fournit en permanence au circuit la position réelle de l’axe, garantissant un maintien stable et précis.

Le servo reçoit une commande de type PWM (Pulse Width Modulation). La largeur de l’impulsion envoyée par Arduino définit la position à atteindre :

• impulsion courte → proche de 0°,

• impulsion moyenne → 90°,

• impulsion longue → proche de 180°.

Grâce à ce système, le servo peut atteindre et maintenir une position avec une très bonne précision, ce qui ouvre la porte à d’innombrables possibilités robotiques.

2. Les différents types de servo-moteurs

a. Servo standard (0°–180°)

Ce type de servo est le plus répandu. Son angle de rotation limité et sa précision en font le choix idéal pour :

• bras robotisés éducatifs,

• volets motorisés,

• robots articulés,

• systèmes de déclenchement.

Les modèles les plus courants sont le SG90 (petit servo plastique) et le MG996R (servo à engrenages métalliques plus puissant).

b. Servo à rotation continue

Contrairement au servo standard, ce modèle tourne de manière illimitée, comme un moteur DC, mais reste contrôlé par un signal PWM.
On peut y contrôler :

• sa vitesse,

• son sens de rotation.

Cependant, il n’est pas possible de connaître ni de fixer une position précise. Il est idéal pour fabriquer de petits robots roulants.

c. Servo de précision / servo haut couple

Ces servos sont conçus pour supporter des efforts plus importants. Équipés d’engrenages métalliques et souvent d’un boîtier renforcé, ils sont recommandés pour :

• bras robotisés avancés,

• plateformes orientables lourdes,

• projets nécessitant une forte stabilité mécanique.

3. Branchement du servo-moteur avec Arduino

Chaque servo possède trois fils, généralement codés par couleur :

Couleur	Fonction	Arduino
Marron / Noir	Masse (GND)	GND
Rouge	Alimentation	5V
Orange / Jaune	Signal PWM	Pin numérique (ex. D9)

Précaution importante

Un gros servo peut consommer beaucoup de courant. Il ne faut jamais l’alimenter directement depuis le 5V de l’Arduino au risque de :

• provoquer des redémarrages intempestifs,

• endommager la carte,

• faire chauffer l’alimentation USB.

La solution idéale consiste à utiliser une alimentation externe 5–6V partageant la masse avec l’Arduino.

4. Comment programmer un servo avec Arduino

Arduino met à disposition une bibliothèque simple et efficace pour contrôler les servos :

#include <Servo.h>

Cette librairie permet d’attacher un servo à n’importe quel pin numérique, de choisir l’angle à atteindre et de maintenir automatiquement la position sans intervention supplémentaire de la part du programme.

Exemple simple : positionner un servo aux angles principaux

Veuillez cliquer sur le lien ci-dessous:

https://solutionmeca.blogspot.com/2025/07/capteur-ultrasonique-avec-arduino.html

Voici un code permettant de déplacer un servo successivement à 0°, 90° et 180° :

#include <Servo.h>

Servo servo1;

void setup() {
  servo1.attach(9); // Pin de commande du servo
}

void loop() {
  servo1.write(0);
  delay(1000);
  servo1.write(90);
  delay(1000);
  servo1.write(180);
  delay(1000);
}

Ce programme constitue la base de la majorité des projets impliquant des servos.

5. Exemple complet : balayage automatique (programme radar)

Ce programme fait effectuer un mouvement de va-et-vient fluide au servo, comme un radar rotatif :

#include <Servo.h>

Servo servo1;
int angle = 0;
int sens = 1;

void setup() {
  servo1.attach(9);
}

void loop() {
  servo1.write(angle);
  angle += sens;

  if (angle >= 180 || angle <= 0) {
    sens = -sens;
  }

  delay(10);
}

Cet exemple est largement utilisé dans les projets de radar ultrasonique avec le capteur HC-SR04.

Veuillez cliquer sur le lien ci-dessous:

https://solutionmeca.blogspot.com/2025/11/comment-utiliser-capteur-ultrasons-hc.html

6. Applications pratiques des servo-moteurs

Les servo-moteurs sont présents dans une grande variété de projets Arduino, notamment :

• Bras robotisés et pinces mécaniques

• Les servos permettent le mouvement précis des articulations.

• Voitures intelligentes
  Ils servent à la direction avant ou au pilotage de capteurs.

• Systèmes de balayage de capteurs (HC-SR04)
  Idéal pour créer un radar ou une carte 2D de l’environnement.

• Systèmes de verrouillage et de contrôle d’accès
  Les micro servos sont parfaits pour actionner des serrures miniatures.

• Robots bipèdes ou quadrupèdes
  Ils assurent les mouvements coordonnés des jambes.

• Maquettes motorisées et portails automatisés
  Très présents dans la modélisation mécanique.

7. Problèmes courants et solutions

Problème	Cause probable	Solution recommandée
Le servo tremble	Alimentation insuffisante	Utiliser une alimentation externe 5–6V
Mouvement lent ou imprécis	Servo de faible qualité	Utiliser un servo à engrenages métalliques
Chauffe excessive	Blocage mécanique	Vérifier le système, éviter les charges trop lourdes
Ne répond pas	Mauvais câblage	Vérifier GND, signal et polarité

Conclusion

Le servo-moteur est un élément incontournable dans l’univers Arduino grâce à sa précision, sa simplicité d’utilisation et ses performances fiables. Avec un simple signal PWM, il peut atteindre et maintenir une position avec une grande exactitude, permettant de concevoir une multitude de projets robotiques, éducatifs ou mécaniques.
Que vous soyez débutant ou expérimenté, comprendre le fonctionnement, le branchement et la programmation d’un servo ouvre la porte à des créations riches et variées.

Guide complet pour maîtriser la modulation PWM dans vos projets Arduino. 

Veuillez cliquer sur le lien ci-dessous.

https://solutionmeca.blogspot.com/2025/11/guide-complet-pour-maitriser-la.html

Guide complet pour maîtriser la modulation PWM dans vos projets Arduino

 

Introduction

Dans le monde de l’électronique et de la programmation embarquée, la modulation PWM (Pulse Width Modulation) est l’une des techniques les plus importantes et les plus utilisées pour contrôler la puissance envoyée à un composant. Sur une carte Arduino, le PWM permet de simuler une tension variable grâce à un signal numérique très rapide. Cette méthode est indispensable pour piloter des moteurs, ajuster l’intensité lumineuse d’une LED, gérer la vitesse d’un ventilateur ou encore contrôler la position d’un servo-moteur.

Bien que le PWM soit souvent présenté comme un simple signal ON/OFF, il repose en réalité sur un principe précis : la variation du rapport cyclique. Grâce à Arduino, cette technique devient accessible même aux débutants, tout en offrant suffisamment de possibilités pour répondre aux besoins des projets électroniques les plus avancés. Ce guide détaillé explique le fonctionnement du PWM, son usage avec Arduino, les différences entre PWM standard et signaux spécifiques, ainsi que plusieurs exemples de code utiles.

1. Qu’est-ce que la modulation PWM ?

La modulation PWM, ou modulation de largeur d’impulsion, est une technique qui consiste à allumer et éteindre un signal numérique à une vitesse très élevée. L’idée n’est pas de modifier la tension elle-même, mais le temps pendant lequel le signal reste à l’état HIGH dans un cycle donné.

Vu à l’œil nu, le signal semble constant, car les interruptions sont trop rapides pour être perçues. Pourtant, la puissance moyenne reçue par le composant varie réellement, ce qui permet de simuler une tension intermédiaire.

Ainsi, avec le PWM, un signal numérique peut produire un comportement analogue, ce qui est particulièrement utile puisque les cartes Arduino classiques ne disposent pas de sorties analogiques véritables (seules les entrées peuvent être analogiques).

2. Le duty cycle : clé du fonctionnement du PWM

Le paramètre fondamental du PWM est le duty cycle, ou rapport cyclique. Il correspond au pourcentage du temps pendant lequel le signal est dans l’état HIGH au cours d’un cycle complet.

Voici quelques exemples pour mieux comprendre :

• 0 % de duty cycle : le signal reste constamment à 0 V → résultat : aucune puissance.

• 50 % de duty cycle : le signal est HIGH la moitié du temps → puissance moyenne.

• 100 % de duty cycle : le signal est constamment HIGH → puissance maximale.

Cette modulation permet de contrôler précisément la puissance délivrée à un composant sans avoir besoin d’un convertisseur analogique.

Sur Arduino, la commande PWM est générée automatiquement par la fonction analogWrite(), avec une résolution de 8 bits allant de 0 à 255 :

• analogWrite(pin, 0) correspond à 0 %,

• analogWrite(pin, 255) correspond à 100 %,

• une valeur intermédiaire représente une puissance proportionnelle.

3. Les fréquences PWM sur Arduino

Chaque carte Arduino utilise différents timers internes pour générer des signaux PWM. Par conséquent, les fréquences varient selon les broches utilisées.

Fréquence standard sur Arduino Uno et Nano

• Environ 490 Hz sur la majorité des sorties PWM : 3, 9, 10, 11

• Environ 980 Hz sur les pins 5 et 6

Ces fréquences sont étudiées pour être suffisamment rapides pour des applications comme le contrôle de moteurs ou la variation de luminosité de LED, tout en restant faciles à gérer pour le microcontrôleur.

4. Les pins PWM disponibles sur Arduino

Toutes les broches numériques ne peuvent pas produire du PWM. Sur la plupart des cartes Arduino basées sur l’ATmega328P, les broches supportant le PWM sont signalées par le symbole « ~ ».

Pins PWM sur Arduino Uno / Nano

• 3, 5, 6, 9, 10, 11

Comment reconnaître une pin PWM ?

Sur la carte, un petit symbole ~ est imprimé à côté du numéro de la broche. C’est un indicateur visuel très utile pour les débutants.

5. PWM et servo-moteurs : une différence importante

Il est important de noter que les servo-moteurs n’utilisent pas le PWM classique généré par analogWrite().
Ils utilisent un signal spécifique appelé PPM (Pulse Position Modulation) basé sur des impulsions de durée précise entre 500 µs et 2400 µs.

Voici les équivalences typiques :

• environ 500–600 µs → proche de 0°

• environ 1500 µs → autour de 90°

• environ 2300 µs → proche de 180°

Pour simplifier cette gestion, Arduino propose la bibliothèque Servo.h, qui prend en charge la génération correcte des impulsions.
Ainsi, une simple ligne comme :

servo.write(90);

permet de positionner un servo à 90°, sans devoir gérer manuellement la largeur des impulsions.

6. Générer un signal PWM avec Arduino : exemples pratiques

Exemple 1 : Variation de luminosité d’une LED

L’exemple suivant permet de faire varier la lumière d’une LED de manière fluide et continue :

int led = 9;

void setup() {
  pinMode(led, OUTPUT);
}

void loop() {
  for (int i = 0; i < 255; i++) {
    analogWrite(led, i);
    delay(10);
  }

  for (int i = 255; i > 0; i--) {
    analogWrite(led, i);
    delay(10);
  }
}

Cet exemple montre comment le PWM peut simuler une tension variable pour régler la luminosité.

Exemple 2 : contrôle d’un moteur DC

Le PWM permet de réguler la vitesse d’un moteur DC :

int motor = 5;

void setup() {
  pinMode(motor, OUTPUT);
}

void loop() {
  analogWrite(motor, 150); // Vitesse intermédiaire
  delay(2000);
  analogWrite(motor, 255); // Pleine puissance
  delay(2000);
}

Grâce au PWM, contrôler la vitesse d’un moteur devient simple et précis.

7. Applications principales du PWM avec Arduino.

Le PWM est utilisé dans une très grande variété de projets :

• Diminution ou augmentation progressive de la luminosité

Pour les panneaux lumineux, LED RGB, lampes intelligentes.

• Contrôle de moteurs DC

Idéal pour construire :

• voitures robotisées,

• ventilateurs,

• pompes miniatures.

• Régulation de puissance

Chauffages, résistances, modules thermoélectriques.

• Contrôle de servos (via Servo.h)

Pour la robotique, les bras articulés, les scanners ultrasoniques.

• Gestion du bruit et du chauffage dans les ventilateurs

Le PWM permet une gestion silencieuse et maîtrisée.

8. Limites et précautions du PWM

Bien que très utile, le PWM Arduino a quelques limites :

• Résolution limitée à 8 bits

• Fréquence fixe (certains moteurs préfèrent du 20 kHz ou plus)

• Peut créer du bruit électrique sur les moteurs

• Impossible sur toutes les broches

• Certaines bibliothèques utilisent les mêmes timers et peuvent entrer en conflit (Servo, Tone, IRremote)

Malgré cela, le PWM Arduino reste suffisant pour la majorité des projets éducatifs et prototypes.

Conclusion

Le signal PWM constitue un outil incontournable dans la conception de projets électroniques avec Arduino. Grâce à cette technique de modulation, il devient possible de contrôler avec précision la puissance fournie à une grande variété de composants : LEDs, moteurs, chauffages, ventilateurs ou servos. Facile à mettre en place à l’aide de la fonction analogWrite(), le PWM combine simplicité et efficacité, rendant les projets plus flexibles et plus intuitifs.

Comprendre le fonctionnement du Duty cycle, connaître les limitations de la carte Arduino et savoir choisir la bonne broche pour le PWM sont autant d’éléments essentiels pour travailler proprement et efficacement. Une fois maîtrisé, ce concept ouvre la porte à des réalisations créatives, robustes et innovantes dans l’univers Arduino.

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.