Affichage des articles dont le libellé est Arduino. Afficher tous les articles
Affichage des articles dont le libellé est Arduino. Afficher tous les articles

samedi 10 octobre 2026

Capteur PIR avec Arduino : branchement, code et fonctionnement.

 

Comprendre le capteur de mouvement infrarouge et créer un système de détection avec Arduino.



Le capteur PIR (Passive Infrared Sensor) est un composant électronique très utilisé dans les systèmes de sécurité, les alarmes, l'éclairage automatique et les projets de domotique. Grâce à sa capacité à détecter les variations du rayonnement infrarouge émis par les corps, il permet de reconnaître le passage d'une personne sans contact physique.

Associé à une carte Arduino Uno, Nano ou Mega, le capteur PIR devient un excellent outil pour apprendre l'électronique et la programmation. Il permet notamment de commander une LED, de déclencher un buzzer ou de concevoir un système d'alarme automatique.

Dans ce guide, nous allons découvrir le fonctionnement du capteur PIR, le rôle de sa lentille blanche, son branchement sur Arduino, les différents modes de déclenchement et un programme simple pour réaliser une première expérience.

1. Qu'est-ce qu'un capteur PIR ?

PIR signifie Passive Infrared Sensor, ou capteur infrarouge passif en français. Le terme « passif » indique que le capteur reçoit le rayonnement infrarouge provenant de son environnement au lieu d'émettre lui-même un signal pour détecter les objets.

Les êtres humains et les animaux émettent naturellement un rayonnement infrarouge lié à leur température. Lorsqu'une personne se déplace dans le champ de détection d'un capteur PIR, la distribution du rayonnement infrarouge reçue par le capteur change. L'électronique du module analyse cette variation et produit un signal de sortie.

Le capteur PIR ne mesure donc pas directement la distance d'une personne et ne fournit pas une image. Il sert principalement à détecter les mouvements associés aux variations du rayonnement infrarouge.

Le module HC-SR501 est l'un des modèles les plus connus dans les projets Arduino. Il est généralement équipé d'une lentille blanche, de deux potentiomètres de réglage et d'un cavalier permettant de sélectionner le mode de déclenchement.

2. Comment fonctionne le capteur PIR ?



Le fonctionnement du capteur PIR repose sur un élément pyroélectrique sensible aux variations du rayonnement infrarouge.

Lorsque le rayonnement reçu par cet élément varie, une modification électrique apparaît. Le circuit électronique intégré traite ensuite ce signal et détermine si une détection doit être signalée à la sortie du module.

Le fonctionnement peut être résumé en quatre étapes :

  1. Une personne entre dans le champ de détection du capteur.

  2. Le rayonnement infrarouge reçu par l'élément pyroélectrique varie.

  3. Le circuit électronique analyse le changement détecté.

  4. La sortie du module passe généralement à l'état logique HIGH pendant une durée déterminée.

Arduino peut lire ce signal avec la fonction digitalRead() et exécuter une action, par exemple allumer une LED ou déclencher une alarme.

Il est important de comprendre qu'un capteur PIR réagit surtout aux changements de rayonnement infrarouge. Une personne immobile peut donc ne plus être détectée après le mouvement initial.

3. À quoi sert la lentille blanche du capteur PIR ?



La pièce blanche en forme de dôme placée sur de nombreux modules PIR est une lentille de Fresnel. Elle ne constitue pas simplement une protection plastique : elle joue un rôle optique essentiel.

Cette lentille divise le champ de vision en plusieurs zones et dirige le rayonnement infrarouge vers l'élément sensible situé à l'intérieur du capteur. Lorsqu'une personne traverse ces zones, le rayonnement reçu varie, ce qui facilite la détection du mouvement.

La lentille de Fresnel contribue également à élargir le champ de détection. La portée et l'angle réels dépendent toutefois du modèle du capteur, de la lentille et des conditions d'installation.

Une lentille endommagée, obstruée ou remplacée par un matériau qui transmet mal l'infrarouge peut réduire les performances du système.

4. Les principales broches du module PIR HC-SR501




Le module HC-SR501 comporte généralement trois broches :

  • VCC : alimentation électrique du module.

  • OUT : sortie logique qui indique la détection.

  • GND : connexion à la masse du circuit.

Sur de nombreux modules HC-SR501, l'alimentation est comprise entre environ 4,5 V et 20 V, mais il faut toujours vérifier la documentation de la version utilisée.

Pour un projet avec Arduino Uno, le module peut généralement être alimenté par la broche 5 V de la carte. La sortie OUT est reliée à une entrée numérique d'Arduino.

Attention : les tensions admissibles varient selon les cartes et les capteurs. Pour un ESP32, qui utilise une logique de 3,3 V, il faut vérifier la compatibilité de la sortie du module et ne jamais appliquer directement une tension supérieure à la limite des GPIO.

5. Comment brancher un capteur PIR sur Arduino Uno ?

Pour réaliser un montage simple, préparez le matériel suivant :

  • Une carte Arduino Uno.

  • Un capteur PIR HC-SR501.

  • Une LED.

  • Une résistance de 220 à 330 ohms.

  • Une plaque d'expérimentation.

  • Des fils de connexion.

  • Un câble USB pour programmer Arduino.

Schéma de câblage



Module PIR ou composantArduino Uno
VCC du PIR5V, si compatible avec le module
OUT du PIRD2
GND du PIRGND
Anode de la LEDD13 à travers une résistance
Cathode de la LEDGND

La LED peut également être remplacée par la LED intégrée de nombreuses cartes Arduino Uno, reliée à D13.

Avant de tester le programme, laissez au capteur le temps de se stabiliser après la mise sous tension. Cette durée dépend du module et peut atteindre plusieurs dizaines de secondes.

6. Programme Arduino pour détecter un mouvement



Le programme suivant lit l'état de la sortie du capteur PIR. Lorsque le module signale une détection, Arduino allume la LED. Lorsque le signal redevient LOW, la LED s'éteint.

const int pirPin = 2;
const int ledPin = 13;

void setup() {
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);

  Serial.begin(9600);
  Serial.println("Initialisation du capteur PIR...");
}

void loop() {
  int mouvement = digitalRead(pirPin);

  if (mouvement == HIGH) {
    digitalWrite(ledPin, HIGH);
    Serial.println("Mouvement detecte !");
  } else {
    digitalWrite(ledPin, LOW);
  }

  delay(100);
}

Explication du code

La variable pirPin indique que la sortie du capteur est reliée à la broche numérique 2. La variable ledPin correspond à la LED connectée à la broche 13.

La fonction pinMode() configure les broches. Ensuite, digitalRead() récupère l'état logique envoyé par le capteur.

Si le résultat est HIGH, Arduino considère qu'une détection est signalée et allume la LED avec digitalWrite(). Si le résultat est LOW, la LED s'éteint.

Enfin, Serial.begin(9600) permet d'afficher des messages dans le moniteur série de l'IDE Arduino.

7. Comprendre les modes Repeatable Trigger et Non-Repeatable Trigger

Le module HC-SR501 propose généralement deux modes de déclenchement, sélectionnés grâce à un petit cavalier placé sur les positions H et L.

Repeatable Trigger : mode H

Dans ce mode, lorsqu'un mouvement est détecté, la sortie passe à HIGH. Si une nouvelle détection se produit pendant la durée d'activation, le délai est prolongé ou redémarre selon le fonctionnement du module.

Ce mode est utile pour les éclairages automatiques. Tant que de nouveaux mouvements sont détectés, la lumière peut rester allumée plus longtemps.

Non-Repeatable Trigger : mode L

Dans ce mode, la durée de sortie HIGH est généralement fixée par le déclenchement initial. Une nouvelle détection pendant cette période ne prolonge normalement pas le délai.

Ce fonctionnement peut convenir aux applications dans lesquelles on souhaite une durée d'activation définie.

Le comportement précis dépend de la version du module et de ses réglages. Le potentiomètre de temporisation permet généralement de modifier la durée pendant laquelle la sortie reste active.

8. Comment régler la sensibilité et la temporisation ?

Le HC-SR501 possède généralement deux potentiomètres.

Le premier règle la sensibilité de détection. Une sensibilité plus élevée peut permettre de détecter un mouvement plus éloigné, mais elle peut aussi augmenter les déclenchements indésirables.

Le second règle la temporisation, c'est-à-dire la durée pendant laquelle la sortie reste à HIGH après une détection. La plage disponible dépend du modèle.

Pour régler correctement le module, procédez progressivement : commencez avec une sensibilité moyenne, testez à différentes distances et ajustez la durée selon l'application.

Évitez d'installer le capteur face à une source de chaleur mobile ou dans un environnement où les variations thermiques sont importantes. Ces conditions peuvent provoquer des détections inattendues.

9. Applications du capteur PIR avec Arduino

Le capteur PIR peut être utilisé dans de nombreux projets éducatifs et pratiques :

  • Alarme de mouvement : déclencher un buzzer lorsqu'une personne est détectée.

  • Éclairage automatique : allumer une lampe lorsqu'une personne entre dans une pièce.

  • Domotique : envoyer une commande à un système de contrôle de la maison.

  • Robotique éducative : créer une interaction entre un robot et son environnement.

  • Compteur de passages simple : détecter des événements de passage dans des conditions adaptées, en utilisant une logique de comptage et un placement approprié.

Pour commander un appareil fonctionnant sur le secteur, il ne faut pas connecter directement celui-ci aux broches Arduino. Il faut utiliser un dispositif de commande adapté, correctement isolé et installé en respectant les règles de sécurité électrique.

10. Problèmes fréquents et solutions

Si la LED ne s'allume pas, vérifiez d'abord les connexions VCC, OUT et GND. Assurez-vous que la sortie OUT est reliée à la bonne broche Arduino et que le programme utilise le même numéro de broche.

Si le capteur déclenche sans raison apparente, réduisez progressivement sa sensibilité et vérifiez son emplacement. Les courants d'air chaud, les sources thermiques mobiles, les vibrations et les variations de l'environnement peuvent influencer le résultat.

Si le capteur ne détecte pas une personne, vérifiez l'orientation de la lentille, la distance, l'alimentation et le temps de stabilisation. Le déplacement transversal dans le champ de détection est souvent plus facile à détecter qu'un mouvement directement vers le capteur.

Enfin, n'oubliez pas que le PIR n'est pas une caméra et qu'il ne permet pas d'identifier une personne.

Conclusion

Le capteur PIR est un composant simple et utile pour découvrir la détection de mouvement avec Arduino. Son fonctionnement repose sur la détection des variations du rayonnement infrarouge, tandis que sa lentille de Fresnel contribue à diriger ce rayonnement et à organiser le champ de vision.

Grâce à quelques fils, une carte Arduino et une LED, il est possible de réaliser un premier projet de détection. En comprenant les broches, le programme, la sensibilité, la temporisation et les modes Repeatable Trigger et Non-Repeatable Trigger, vous pourrez ensuite concevoir des systèmes plus avancés pour la domotique, les alarmes et la robotique éducative.

Le capteur PIR constitue ainsi une excellente étape pour progresser en électronique et en programmation Arduino.

vendredi 18 septembre 2026

Système d’irrigation automatique avec Arduino.

 

Système d’irrigation automatique avec Arduino 

Titre secondaire : Comment créer un arrosage intelligent avec Arduino et un capteur d’humidité du sol ?



L’irrigation automatique avec Arduino est un projet pratique qui permet de découvrir à la fois l’électronique, la programmation et les principes de l’automatisation. Grâce à une carte Arduino, un capteur d’humidité du sol et une petite pompe à eau, il est possible de réaliser un système capable de surveiller automatiquement l’état de la terre et de déclencher l’arrosage lorsque la plante manque d’eau.

Ce projet est particulièrement intéressant pour les débutants, les passionnés d’Arduino et les enfants qui souhaitent apprendre la robotique à travers une réalisation concrète. Il permet également de comprendre comment les capteurs peuvent être utilisés pour prendre des décisions automatiquement.

Dans cet article, nous allons découvrir le fonctionnement d’un système d’irrigation Arduino, les composants nécessaires, le principe du montage, la programmation et plusieurs idées pour améliorer le projet.

Qu’est-ce qu’un système d’irrigation avec Arduino ?

Un système d’irrigation avec Arduino est un dispositif électronique qui automatise l’arrosage d’une plante ou d’un petit jardin.

Le principe est simple : un capteur d’humidité du sol mesure la quantité d’humidité présente dans la terre. Arduino récupère cette information et la compare à une valeur définie dans le programme.

Lorsque la terre devient trop sèche, Arduino commande une pompe à eau. La pompe envoie alors de l’eau vers la plante. Lorsque l’humidité atteint un niveau suffisant, Arduino arrête automatiquement la pompe.

Le système fonctionne donc selon une logique simple :

Mesurer → analyser → décider → arroser → arrêter.

Cette méthode permet de transformer un simple montage électronique en un véritable petit système d’agriculture intelligente.

Les composants nécessaires



Pour réaliser un projet d’irrigation automatique avec Arduino, plusieurs composants électroniques sont nécessaires.

1. Arduino Uno

L’Arduino Uno constitue le cerveau du système. Il reçoit les informations du capteur d’humidité et exécute le programme chargé dans sa mémoire.

Arduino peut ensuite commander différents composants comme une pompe, un relais, une LED ou un buzzer.

2. Capteur d’humidité du sol


Le capteur d’humidité du sol permet de déterminer si la terre est humide ou sèche.

Il existe plusieurs modèles de capteurs. Les modèles simples possèdent généralement deux sondes qui sont placées dans la terre. Le module fournit ensuite une valeur que l’Arduino peut lire.

Il est important de calibrer le capteur, car la valeur obtenue peut varier selon le type de terre, l’humidité et le modèle utilisé.

3. Pompe à eau



La petite pompe à eau permet de transporter l’eau du réservoir vers la plante.

Une pompe ne doit généralement pas être alimentée directement par une sortie Arduino. Il faut utiliser un dispositif de commande adapté, comme un module relais ou un transistor/MOSFET selon le type de pompe.

4. Module relais



Le relais permet à Arduino de commander une charge qui nécessite davantage de courant que ce qu’une sortie de la carte peut fournir.

Arduino envoie simplement un signal au relais. Le relais permet ensuite d’activer ou de désactiver la pompe.

5. Tuyau et réservoir d’eau

Un petit tuyau permet d’acheminer l’eau depuis le réservoir jusqu’au pot de la plante.

Pour un projet pédagogique, une petite bouteille ou un récipient peut servir de réservoir.

6. Alimentation

Le système doit disposer d’une alimentation adaptée à Arduino et à la pompe. Il faut toujours respecter la tension et le courant recommandés pour chaque composant.

Comment fonctionne l’irrigation automatique ?

Le fonctionnement du projet peut être expliqué en quelques étapes.

Tout d’abord, le capteur mesure l’humidité de la terre. Arduino lit ensuite la valeur envoyée par le capteur.

Le programme contient un seuil permettant de déterminer si la terre est suffisamment humide.

Par exemple :

  • Terre humide → la pompe reste arrêtée.

  • Terre sèche → Arduino active la pompe.

  • Humidité suffisante → Arduino arrête la pompe.

Cette logique peut être représentée ainsi :

Capteur → Arduino → Relais → Pompe → Eau → Plante

Le système peut fonctionner automatiquement pendant plusieurs heures ou plusieurs jours sans intervention permanente de l’utilisateur.

Branchement général du système.

Pour un projet simple, le capteur d’humidité peut être connecté à une entrée analogique de l’Arduino.

Par exemple :

  • VCC du capteur → 5V Arduino

  • GND du capteur → GND Arduino

  • AOUT du capteur → A0 Arduino

Le relais peut être connecté à une sortie numérique, par exemple :

  • VCC → 5V

  • GND → GND

  • IN → broche numérique Arduino

La pompe doit être alimentée selon ses caractéristiques électriques et commandée par le relais ou un circuit de puissance approprié.

Attention : la pompe ne doit pas être branchée directement sur une sortie numérique de l’Arduino.

Exemple de programme Arduino.

Voici un exemple simple permettant de comprendre le principe du système :

const int capteurHumidite = A0;
const int pompe = 8;

int seuil = 600;

void setup() {
  pinMode(pompe, OUTPUT);
  digitalWrite(pompe, LOW);

  Serial.begin(9600);
}

void loop() {

  int humidite = analogRead(capteurHumidite);

  Serial.print("Humidite du sol : ");
  Serial.println(humidite);

  if (humidite > seuil) {
    digitalWrite(pompe, HIGH);
    Serial.println("Sol sec : arrosage");
  }
  else {
    digitalWrite(pompe, LOW);
    Serial.println("Sol humide : pompe arrêtée");
  }

  delay(1000);
}

La valeur du seuil dépend du capteur et de son orientation. Il est donc préférable de réaliser plusieurs tests avant de choisir une valeur définitive.

Pourquoi utiliser un capteur d’humidité du sol ?

L’utilisation d’un capteur d’humidité présente un avantage important : le système ne fonctionne pas simplement selon une minuterie.

Avec une minuterie, la pompe peut arroser la plante même si la terre contient déjà suffisamment d’eau.

Avec un capteur d’humidité, Arduino prend sa décision à partir de l’état réel du sol.

Cela permet de créer un système plus intelligent et constitue une excellente introduction à l’automatisation agricole.

Irrigation Arduino pour apprendre la robotique

Le projet d’irrigation automatique est également très intéressant dans l’apprentissage de la robotique.

Les enfants peuvent découvrir plusieurs notions importantes :

  • les capteurs ;

  • les entrées analogiques ;

  • les sorties numériques ;

  • les conditions if ;

  • les variables ;

  • les relais ;

  • les moteurs et pompes ;

  • l’alimentation électrique ;

  • la programmation Arduino ;

  • l’automatisation.

Le projet peut être réalisé progressivement afin que l’enfant comprenne chaque partie avant de construire le système complet.

Par exemple, une première activité peut consister à afficher la valeur du capteur dans le Moniteur série Arduino. Ensuite, l’enfant peut commander une LED lorsque la terre devient sèche. Enfin, la LED peut être remplacée par une pompe.

Cette progression rend le projet plus facile à comprendre.

Comment améliorer le système d’irrigation Arduino ?

Une fois le système de base terminé, plusieurs améliorations sont possibles.

Ajouter un écran LCD

Un écran LCD peut afficher :

Humidité : 45 %
État : Sol humide
Pompe : OFF

L’enfant peut ainsi visualiser les informations du système.

Ajouter un buzzer

Un buzzer peut produire une alerte sonore lorsque la terre devient très sèche.

https://solutionmeca.blogspot.com/2026/09/les-buzzers-utilises-avec-arduino.html

Par exemple, Arduino peut faire retentir le buzzer pendant quelques secondes avant de démarrer la pompe.

Ajouter une LED

Une LED rouge peut indiquer que le sol est sec tandis qu’une LED verte peut indiquer que l’humidité est suffisante.

Cette solution est particulièrement intéressante pour les projets scolaires.

Ajouter un capteur de température et d’humidité

Un capteur comme le DHT11 peut mesurer la température et l’humidité de l’air. Les informations peuvent être combinées avec celles du capteur d’humidité du sol afin de créer un projet plus complet.

Ajouter une commande à distance

Pour aller plus loin, une carte ESP32 peut être utilisée afin de connecter le système à Internet. Les données d’humidité peuvent alors être affichées sur une application ou une interface web.

Le projet évolue ainsi vers une solution d’irrigation intelligente connectée.

Les avantages d’un système d’irrigation automatique

Un système d’arrosage automatique présente plusieurs avantages.

Il permet tout d’abord d’automatiser une tâche répétitive. Il peut également aider à éviter un arrosage inutile lorsque la terre est déjà suffisamment humide.

Sur le plan pédagogique, le projet permet surtout de relier la programmation à une application réelle.

L’enfant ne se contente pas d’écrire du code : il programme une carte électronique qui observe son environnement et agit en fonction des informations reçues.

C’est exactement ce type de projet qui permet de comprendre les bases de la robotique et des systèmes automatisés.

Conclusion

Le système d’irrigation automatique avec Arduino est un excellent projet pour apprendre l’électronique, la programmation et la robotique. Avec quelques composants simples, il est possible de construire un dispositif capable de mesurer l’humidité du sol et de commander automatiquement une pompe à eau.

Le projet peut commencer avec une simple LED et un capteur d’humidité, puis évoluer progressivement vers un système complet équipé d’un relais, d’une pompe, d’un écran LCD, d’un buzzer, de plusieurs capteurs et même d’une connexion Internet.

Pour les enfants, ce projet représente une excellente activité pratique : ils apprennent à mesurer, programmer, tester et résoudre des problèmes tout en construisant un système qui fonctionne réellement.

L’irrigation avec Arduino constitue ainsi une porte d’entrée accessible vers l’agriculture intelligente, l’IoT, l’automatisation et la robotique.

mardi 8 septembre 2026

Les buzzers utilisés avec Arduino.

 

Les buzzers utilisés avec Arduino : guide complet pour débutants



Découvrez les différents types de buzzers, leur fonctionnement et leur utilisation dans vos projets Arduino

Le buzzer est l'un des composants électroniques les plus simples et les plus intéressants à utiliser avec une carte Arduino. Il permet de produire des sons, des alertes, des signaux sonores et même des mélodies. Très populaire dans les projets électroniques, robotiques et éducatifs, le buzzer est particulièrement adapté aux débutants et aux enfants qui découvrent la programmation avec Arduino.

Dans un projet Arduino, un buzzer peut être utilisé pour créer une alarme, signaler la détection d'un obstacle, produire un avertissement, jouer une musique ou rendre un robot plus interactif. Il existe principalement deux types de buzzers utilisés avec Arduino : le buzzer actif et le buzzer passif.

Dans ce guide complet, nous allons découvrir les différents types de buzzers Arduino, leurs pattes, leur fonctionnement, leurs différences et les méthodes pour les connecter et les programmer.

Qu'est-ce qu'un buzzer Arduino ?

Un buzzer est un composant électronique capable de produire un son lorsqu'il reçoit un signal électrique. Il est souvent utilisé comme indicateur sonore dans les appareils électroniques.

Le buzzer peut produire un simple son répétitif comme « Bip Bip » ou générer différentes fréquences musicales selon son type et sa programmation.

Avec Arduino, le buzzer peut être contrôlé directement par le programme. La carte Arduino peut décider à quel moment le buzzer doit fonctionner, combien de temps il doit produire un son et, dans le cas d'un buzzer passif, quelle fréquence sonore il doit générer.

Les buzzers sont très utilisés dans :

  • Les robots Arduino.

  • Les systèmes d'alarme.

  • Les détecteurs de mouvement.

  • Les systèmes de sécurité.

  • Les jeux électroniques.

  • Les voitures et robots intelligents.

  • Les projets éducatifs pour enfants.

  • Les systèmes d'alerte.

  • Les détecteurs d'obstacles.

  • Les projets de domotique.

Combien de types de buzzers peut-on utiliser avec Arduino ?

Il existe principalement deux types de buzzers utilisés dans les projets Arduino :

  1. Le buzzer actif.

  2. Le buzzer passif.

Même si leur apparence peut être similaire, leur fonctionnement est différent. Il est donc important de connaître la différence entre un buzzer actif et un buzzer passif avant de commencer un projet Arduino.

Le buzzer actif Arduino



Le buzzer actif est le type de buzzer le plus simple à utiliser. Il possède un circuit électronique interne qui permet de générer automatiquement une fréquence sonore.

Lorsque le buzzer actif reçoit une alimentation électrique, il commence directement à produire un son.

Par exemple, si Arduino envoie un signal HIGH au buzzer, celui-ci peut produire immédiatement un son.

Le buzzer actif est particulièrement adapté aux débutants qui souhaitent apprendre les bases de la programmation électronique.

Fonctionnement du buzzer actif

Le principe est très simple :

  • Arduino envoie un signal électrique.

  • Le buzzer reçoit ce signal.

  • Le circuit interne du buzzer génère une fréquence.

  • Le buzzer produit un son.

Le buzzer actif produit généralement un son fixe. Il ne permet pas facilement de jouer plusieurs notes musicales différentes.

Utilisation du buzzer actif

Le buzzer actif est souvent utilisé pour :

  • Créer une alarme sonore.

  • Signaler une erreur.

  • Avertir d'un danger.

  • Indiquer qu'un robot détecte un obstacle.

  • Créer un système de sécurité.

  • Produire un signal sonore dans un jeu électronique.

Le buzzer passif Arduino






Le buzzer passif fonctionne différemment du buzzer actif. Il ne possède pas de circuit interne permettant de produire automatiquement une fréquence sonore.

Pour générer un son, Arduino doit envoyer une fréquence électrique au buzzer.

C'est pour cette raison que le buzzer passif est plus intéressant pour créer des projets musicaux avec Arduino.

Grâce au buzzer passif, il est possible de produire différentes notes musicales comme :

  • DO

  • RÉ

  • MI

  • FA

  • SOL

  • LA

  • SI

Arduino peut modifier la fréquence envoyée au buzzer afin de produire différents sons.

Fonctionnement du buzzer passif

Le fonctionnement est le suivant :

  • Arduino génère une fréquence.

  • Cette fréquence est envoyée au buzzer.

  • Le buzzer transforme le signal électrique en vibration sonore.

  • L'utilisateur entend un son.

Pour programmer un buzzer passif, Arduino utilise souvent la fonction tone().

Exemple :

tone(8, 440);

Dans cet exemple, Arduino envoie une fréquence de 440 Hz sur la broche 8. Cette fréquence correspond approximativement à la note LA.

Pour arrêter le son, on peut utiliser :

noTone(8);

Les pattes du buzzer

Un buzzer électronique possède généralement deux pattes principales.

La patte positive (+)

La patte positive est souvent identifiée par le symbole « + ».

Elle reçoit le signal ou l'alimentation électrique.

Dans un projet Arduino, cette patte peut être connectée à une broche numérique, par exemple D8.

La patte négative (-)

La deuxième patte est la patte négative.

Elle doit généralement être connectée à la masse de la carte Arduino, appelée GND.

Schéma simple de connexion

        BUZZER
       ┌───────┐
       │   +   │
       └─┬───┬─┘
         │   │
        D8  GND
       ARDUINO

La connexion est donc très simple :

  • Patte positive → Broche numérique Arduino.

  • Patte négative → GND.

Les modules buzzer à trois broches




Certains buzzers sont vendus sous forme de modules électroniques.

Ces modules peuvent posséder trois broches :

  • VCC.

  • GND.

  • S ou I/O.

Signification des broches

VCC : alimentation positive.

GND : masse ou alimentation négative.

S / Signal / I/O : broche utilisée pour recevoir le signal provenant d'Arduino.

Ces modules sont souvent utilisés dans les kits électroniques Arduino destinés aux étudiants et aux enfants.

Différence entre buzzer actif et buzzer passif

La principale différence entre les deux types de buzzers concerne la production du son.

CaractéristiqueBuzzer actifBuzzer passif
Production du sonAutomatiqueContrôlée par Arduino
SonFixeVariable
MusiqueNon ou limitéeOui
ProgrammationSimplePlus avancée
Fonction ArduinoHIGH / LOWtone()
UtilisationAlarmesMusique et effets sonores

Le buzzer actif est idéal pour produire une simple alerte sonore.

Le buzzer passif est préférable lorsque l'on souhaite produire plusieurs fréquences et créer des mélodies.

Comment connecter un buzzer à Arduino ?

Pour connecter un buzzer à Arduino, vous avez besoin de :

  • Une carte Arduino Uno.

  • Un buzzer actif ou passif.

  • Des fils de connexion.

  • Une breadboard, également appelée plaque d'essai.

La connexion classique consiste à relier la patte positive du buzzer à une sortie numérique Arduino et la patte négative à GND.

Par exemple :

Arduino D8  ─────── + Buzzer
Arduino GND ─────── - Buzzer

Exemple de programme Arduino avec un buzzer actif

Voici un programme simple permettant de faire fonctionner un buzzer actif.

#define BUZZER 8

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

void loop() {

  digitalWrite(BUZZER, HIGH);
  delay(1000);

  digitalWrite(BUZZER, LOW);
  delay(1000);
}

Le résultat est simple : le buzzer produit un son pendant une seconde, puis s'arrête pendant une seconde.

Le programme recommence ensuite automatiquement.

Ce type de projet est idéal pour les enfants qui commencent à apprendre Arduino.

Exemple de programme avec un buzzer passif

Le buzzer passif permet de produire différentes fréquences.

Voici un exemple simple :

#define BUZZER 8

void setup() {
}

void loop() {

  tone(BUZZER, 262);
  delay(500);

  tone(BUZZER, 294);
  delay(500);

  tone(BUZZER, 330);
  delay(500);

  noTone(BUZZER);
  delay(1000);
}

Dans cet exemple, le buzzer produit trois notes différentes.

262 Hz correspond approximativement à la note DO.

294 Hz correspond à la note RÉ.

330 Hz correspond à la note MI.

Cette méthode permet de créer des musiques, des effets sonores et des systèmes interactifs.

Applications du buzzer dans les projets Arduino

Le buzzer est utilisé dans de nombreux projets électroniques et robotiques.

Robot éviteur d'obstacles

Un robot peut utiliser un capteur ultrasonique pour détecter un obstacle.

Lorsqu'un obstacle est détecté, Arduino peut activer le buzzer pour avertir l'utilisateur.

Système d'alarme

Le buzzer peut être utilisé avec un détecteur de mouvement.

Lorsque le capteur détecte une présence, Arduino active immédiatement une alarme sonore.

Détecteur de distance

Avec un capteur HC-SR04, le buzzer peut produire des sons de plus en plus rapides lorsque l'objet se rapproche.

Jeu électronique

Le buzzer peut produire des sons lorsque le joueur gagne ou perd.

Il peut également servir à créer des boutons sonores ou des jeux éducatifs.

Robot intelligent

Dans un robot Arduino, le buzzer permet d'ajouter une communication sonore.

Le robot peut ainsi avertir l'utilisateur lorsqu'il détecte un problème ou termine une action.

Comment choisir entre un buzzer actif et passif ?

Le choix dépend de votre projet.

Choisissez un buzzer actif si vous souhaitez :

  • Produire une alarme simple.

  • Créer un système d'avertissement.

  • Utiliser une programmation facile.

  • Réaliser un projet pour débutants.

Choisissez un buzzer passif si vous souhaitez :

  • Jouer de la musique.

  • Créer différentes notes.

  • Produire plusieurs fréquences.

  • Réaliser des effets sonores avancés.

Apprendre Arduino avec les buzzers

Le buzzer est un excellent composant pour apprendre l'électronique et la programmation.

Pour les enfants, il permet de comprendre facilement la relation entre le programme informatique et le monde réel.

Lorsqu'un enfant écrit un programme et entend immédiatement un son, il comprend rapidement que le code Arduino peut contrôler des composants électroniques.

Les projets avec buzzer permettent également d'apprendre plusieurs notions importantes :

  • Les sorties numériques.

  • Les signaux HIGH et LOW.

  • Les fréquences.

  • La fonction tone().

  • Les délais avec delay().

  • Les conditions avec if.

  • Les capteurs et les alertes.

Le buzzer peut donc être utilisé dès les premières leçons Arduino.

Conclusion

Le buzzer est un composant indispensable dans de nombreux projets Arduino. Simple, économique et facile à programmer, il permet d'ajouter des sons et des alertes aux montages électroniques.

Il existe principalement deux types de buzzers : le buzzer actif et le buzzer passif.

Le buzzer actif produit directement un son lorsqu'il reçoit un signal électrique. Il est idéal pour les alarmes et les systèmes d'avertissement.

Le buzzer passif, quant à lui, permet de produire différentes fréquences et de jouer des mélodies grâce à la fonction tone() d'Arduino.

Comprendre la différence entre ces deux composants permet de choisir le buzzer adapté à chaque projet.

Que vous soyez débutant, étudiant, enseignant ou passionné de robotique, apprendre à utiliser un buzzer avec Arduino est une excellente étape pour découvrir l'électronique, la programmation et la robotique.

Le buzzer est petit, mais il peut donner beaucoup de vie à vos projets Arduino !

lundi 17 novembre 2025

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 :

BrocheNomFonction
VCCAlimentation (5V)Alimente le capteur
TrigTriggerEnvoie le signal ultrasonique
EchoEchoReçoit le signal réfléchi
GNDMasseRelie 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 :




Distance (cm)=Dure (µs)×0.03432\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-SR04Arduino
VCC5V
GNDGND
TrigBroche 9
EchoBroche 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éristiqueValeur
Tension d’alimentation5V DC
Courant typique15 mA
Fréquence ultrasonique40 kHz
Portée de mesure2 cm à 400 cm
Précision±3 mm
Angle de détectionenviron 15°
Temps de réponse10 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 :

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


CapteurTechnologiePortéePrécisionPrix
HC-SR04Ultrasonique2–400 cm±3 mmTrès faible
GP2Y0A21Infrarouge10–80 cm±1 cmMoyen
VL53L0XLaser (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
.

mercredi 2 juillet 2025

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);

}







Projet 1 : Entrées et sorties de l’ESP32 (Inputs/Outputs).

   Dans ce guide de démarrage, vous apprendrez à lire des entrées numériques, comme un bouton-poussoir ou un interrupteur, et à commander de...