Buzzers piézo actifs et passifs avec Arduino

Les buzzers piézo sont des dispositifs simples produisant du son, largement utilisés dans les projets électroniques. Ils alertent les utilisateurs par des bips, des tonalités ou des alarmes.

Il existe deux types principaux de buzzers : actifs et passifs. Chaque type fonctionne différemment et convient à des applications variées. Les buzzers actifs ont des oscillateurs intégrés, ils produisent donc du son dès qu’ils sont alimentés. Les buzzers passifs nécessitent un signal externe, comme une onde carrée, pour générer du son.

Dans les sections suivantes, nous explorerons les différences entre les buzzers actifs et passifs, comment les connecter et comment les programmer efficacement.

Pièces requises

Vous aurez besoin d’un buzzer passif et d’un buzzer actif. J’en ai listé deux ci-dessous, mais il existe de nombreuses alternatives. Notez que le buzzer actif est prévu pour du 5V, tandis que le buzzer passif fonctionne de 3V à 5V.

Pour le microcontrôleur, j’ai utilisé un Arduino Uno pour ce projet, mais tout autre Arduino ou ESP32 conviendra également. Une breadboard, quelques câbles et un jeu de résistances seront aussi utiles.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Principe de fonctionnement des buzzers piézo

Un buzzer piézo fonctionne grâce à l’effet piézoélectrique. Cet effet se produit dans certains matériaux céramiques qui changent de forme lorsqu’une tension est appliquée.

À l’intérieur du buzzer se trouve un disque fin en céramique piézoélectrique. Ce disque est fixé à un diaphragme métallique. Le diaphragme métallique agit comme une membrane flexible.

Lorsqu’une tension est appliquée aux bornes, un champ électrique se crée dans le matériau céramique. La céramique se dilate ou se contracte selon la polarité de la tension. Le changement de dimension est très faible, mais suffisant pour plier le diaphragme métallique attaché.

Si une tension continue est appliquée, le disque se déplace vers une position et y reste (buzzer passif). Aucun son continu n’est produit dans ce cas. Pour générer du son, il faut appliquer une tension alternative. La tension change de polarité à une fréquence spécifique. Les buzzers actifs ont un circuit oscillateur intégré qui génère cette tension alternative.

À mesure que la tension alterne, le disque céramique se dilate et se contracte rapidement. Cela fait fléchir le diaphragme métallique de haut en bas. Le mouvement du diaphragme pousse et tire l’air environnant. Cela crée des ondes de pression dans l’air, que nous percevons comme du son.

La fréquence du son est égale à la fréquence du signal appliqué. Le volume dépend de l’amplitude de la tension et de la conception mécanique du buzzer. Beaucoup de buzzers piézo sont conçus pour résonner à une fréquence spécifique afin d’augmenter le volume sonore.

Différences entre buzzers passifs et actifs

Buzzer passif

Un buzzer passif contient uniquement l’élément piézoélectrique et le diaphragme. Il ne comprend pas de circuit oscillateur interne. Lorsqu’on applique une tension continue, il ne produit pas de son continu. Il ne fait qu’un clic lorsque la tension change.

L’image suivante montre les parties d’un buzzer passif. Comme vous pouvez le voir, le boîtier ne contient que l’élément piézo, sans électronique :

Pour générer une tonalité avec un buzzer passif, vous devez appliquer un signal alternatif. C’est généralement une onde carrée générée par un Arduino ou ESP32 via PWM. La fréquence de sortie définit directement la fréquence sonore. Cela permet de produire différentes tonalités et mélodies simples.

Buzzer actif

Un buzzer actif inclut un circuit oscillateur intégré. Lorsqu’on applique une tension continue dans la plage nominale, le circuit interne génère automatiquement un signal alternatif pour l’élément piézo. Le buzzer produit une tonalité fixe sans génération de signal externe. Il suffit de mettre la broche de contrôle à HIGH pour qu’il sonne. La fréquence est prédéfinie par l’oscillateur interne – généralement entre 2 et 4 kHz – et ne peut pas être modifiée.

Résumé

Les buzzers passifs offrent un contrôle total sur la fréquence et le timing. Ils conviennent aux applications nécessitant différentes tonalités ou mélodies. Les buzzers actifs sont plus simples à utiliser. Ils conviennent aux alarmes ou indicateurs où une seule tonalité fixe suffit.

Du point de vue microcontrôleur, un buzzer passif nécessite une broche capable de PWM ou une génération de signal basée sur un timer. Un buzzer actif ne requiert qu’une broche numérique pouvant commuter entre HIGH et LOW.

Reconnaître les buzzers actifs et passifs

Les buzzers passifs et actifs se ressemblent extérieurement et sont facilement confondus. Identifier si un buzzer est actif ou passif est crucial avant de le connecter à votre Arduino ou ESP32.

Comme mentionné, les buzzers actifs ont un circuit intégré avec oscillateur. Ils ont donc seulement besoin d’une tension continue pour produire du son. En revanche, les buzzers passifs n’ont pas cet oscillateur interne. Ils nécessitent un signal externe, comme une onde carrée, pour générer du son.

Arrière

Typiquement, l’arrière d’un buzzer actif est entièrement recouvert de résine époxy noire, tandis que les buzzers passifs laissent apparaître un circuit imprimé :

Hauteur

En raison du circuit interne, le boîtier d’un buzzer actif est généralement plus haut que celui d’un buzzer passif, et la broche du terminal positif est souvent plus longue :

Autocollant

Enfin, si vous achetez un buzzer neuf, les buzzers actifs ont souvent un autocollant sur le trou sonore qu’il faut retirer avant utilisation :

Résistance

Outre l’apparence, vous pouvez aussi mesurer la résistance du buzzer pour déterminer son type. Les buzzers actifs ont une résistance élevée d’environ 40 Ω ou se mesurent comme un circuit ouvert. Les buzzers passifs ont une résistance plus faible, supérieure à 20 Ω entre leurs bornes.

Test avec tension

La méthode la plus sûre pour déterminer le type de buzzer est de le connecter à 5V. Un buzzer actif émettra un son, tandis qu’un buzzer passif restera silencieux ou produira un seul clic.

Résumé

Le tableau suivant résume les différences entre buzzers actifs et passifs :

Caractéristique	Buzzer actif	Buzzer passif
Oscillateur interne	Oui	Non
Son direct en DC	Oui	Non ou clics
Arrière	Scellé avec époxy noire	Circuit imprimé visible
Capacité sonore	Tonalité fixe	Tonalités variées/musicales
Résistance	Élevée (≈ 40 Ω)	Faible (≈ 20 Ω)
Courant	1 … 15 mA	1 … 5 mA (avec pics de courant)

Choisir le bon buzzer pour vos projets

Le choix du buzzer dépend des besoins et de la complexité de votre projet. Les buzzers actifs sont simples à utiliser. Ils ont un oscillateur intégré, il suffit donc de les alimenter pour produire du son. Ils sont idéaux pour des alertes ou alarmes simples où une tonalité constante suffit.

En revanche, les buzzers passifs nécessitent un signal externe pour générer du son. Ils ne produisent pas de son seuls. Vous envoyez une onde carrée ou un signal tonal depuis votre Arduino pour contrôler la hauteur et la durée. Cette flexibilité rend les buzzers passifs parfaits pour des projets avec mélodies, effets sonores ou tonalités variables.

Si vous voulez gagner du temps et garder votre code simple, choisissez un buzzer actif. Il est plug-and-play et fonctionne bien pour des notifications basiques. Cependant, si votre projet implique de la musique ou des sons complexes, un buzzer passif offre plus de contrôle et de créativité.

Pensez aussi aux besoins en énergie et à la taille. Les buzzers actifs consomment souvent plus de courant à cause de l’oscillateur interne. Les buzzers passifs peuvent être plus économes en énergie si vous contrôlez bien le signal. De plus, ils peuvent être achetés sans boîtier, ce qui les rend particulièrement adaptés aux projets compacts.

N’oubliez pas de vérifier la fiche technique pour les tensions et courants afin d’assurer la compatibilité.

Connecter un buzzer actif à l’Arduino

Connecter un buzzer actif à un Arduino est simple. Comme les buzzers actifs ont des oscillateurs intégrés, ils ont seulement besoin d’une tension continue pour produire du son. Vous n’avez donc pas à générer un signal tonal depuis l’Arduino ; il suffit d’alimenter le buzzer pour qu’il émette un bip. Cependant

Commencez par identifier les bornes positive et négative du buzzer. La borne positive est généralement marquée d’un plus (+) ou a une patte plus longue.

Connectez cette borne à une des broches numériques de l’Arduino, par exemple la broche 8. Puis, connectez la borne négative à la masse (GND) de l’Arduino comme montré ci-dessous :

Une fois câblé, vous pouvez contrôler le buzzer en mettant la broche numérique à HIGH ou LOW – comme pour une LED. Mettre la broche à HIGH alimente le buzzer et le fait sonner, tandis que LOW l’éteint.

Voici un exemple minimaliste de sketch qui allume le buzzer pendant une seconde, puis l’éteint pendant une seconde, en boucle :

const int buzzerPin = 8;

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

void loop() {
  digitalWrite(buzzerPin, HIGH);  // Turn buzzer on
  delay(1000);                    // Wait for 1 second
  digitalWrite(buzzerPin, LOW);   // Turn buzzer off
  delay(1000);                    // Wait for 1 second
}

Ce code fait bip-bip au buzzer toutes les secondes. Comme le buzzer actif gère la génération de tonalité en interne, vous ne pouvez pas utiliser la fonction tone() ou les signaux PWM pour contrôler le buzzer.

Connecter un buzzer passif à l’Arduino

Connecter un buzzer passif à un Arduino est facile mais demande un peu plus d’attention qu’un buzzer actif. Contrairement aux buzzers actifs, les buzzers passifs ont besoin d’un signal PWM pour produire du son, vous utiliserez donc une broche numérique capable de PWM. Le tableau suivant liste les broches PWM des cartes Arduino courantes :

Carte	Broches PWM
Arduino UNO	3, 5, 6, 9, 10, 11
Arduino Nano	3, 5, 6, 9, 10, 11
Arduino Mega 2560	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 44, 45, 46
Arduino Leonardo	3, 5, 6, 9, 10, 11, 13
Arduino Micro	3, 5, 6, 9, 10, 11, 13
Arduino Due	2 à 13
Arduino Zero	3, 4, 5, 6, 8, 9, 10, 11, 12, 13

Pour connecter le buzzer, commencez par identifier les bornes positive et négative. La borne positive est généralement marquée sur le PCB ou un plus est indiqué sur le boîtier. Souvent, le plus est très discret et difficile à voir :

Connectez la borne positive à une broche numérique capable de PWM sur l’Arduino, par exemple la broche 11. Puis, connectez la borne négative à la masse (GND) de l’Arduino.

Les buzzers passifs consomment très peu de courant, en moyenne de 1 à 5 mA. Mais ils peuvent avoir des pics de courant lors des commutations. Il est donc recommandé d’ajouter une résistance de limitation de courant en série avec le buzzer. Une résistance de 100 Ω fonctionne bien dans la plupart des cas. Connectez la résistance entre la broche PWM 11 de l’Arduino et la borne positive du buzzer comme montré ci-dessous.

Cependant, si le volume est trop faible, vous pouvez essayer de retirer la résistance de 100 Ω ou de la remplacer par une valeur plus faible.

Le circuit permet à l’Arduino d’envoyer des signaux à fréquence variable au buzzer passif, lui permettant de produire différentes tonalités. Rappelez-vous, le buzzer passif ne sonnera pas sans génération d’un signal PWM dans votre code.

Exemples de code pour buzzers actifs

Les buzzers actifs sont simples à utiliser avec Arduino car ils n’ont besoin que d’une tension continue pour produire du son. Vous n’avez pas à générer un signal tonal ; il suffit d’allumer ou d’éteindre le buzzer en le connectant à une broche GPIO numérique.

Voici un exemple basique pour faire sonner un buzzer actif pendant une seconde :

int buzzerPin = 8; 

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

void loop() {
  digitalWrite(buzzerPin, HIGH);  // Turn buzzer on
  delay(1000);                    // Wait for 1 second
  digitalWrite(buzzerPin, LOW);   // Turn buzzer off
  delay(1000);                    // Wait for 1 second
}

Ce code configure la broche du buzzer en sortie. Puis il allume le buzzer pendant une seconde et l’éteint pendant une seconde en boucle. Le buzzer émettra un bip continu pendant l’état HIGH.

Vous pouvez aussi créer des motifs simples en modifiant les temps de délai. Par exemple, pour faire un bip court suivi d’une pause :

void loop() {
  digitalWrite(buzzerPin, HIGH);
  delay(200);                   // Short beep
  digitalWrite(buzzerPin, LOW);
  delay(800);                   // Longer pause
}

Cette méthode fonctionne bien pour les alarmes, notifications ou effets sonores simples. Comme les buzzers actifs ont des oscillateurs intégrés, vous n’avez pas à vous soucier de générer des fréquences dans votre code. Cependant, vous pouvez légèrement modifier la fréquence en ajoutant une résistance en série, comme pour le buzzer passif. Essayez une résistance de 100 Ω et vous entendrez une tonalité un peu plus basse.

En résumé, contrôler un buzzer actif avec Arduino est simple. Il suffit d’appliquer des signaux HIGH ou LOW pour allumer ou éteindre le son.

Exemples de code pour buzzers passifs

Les buzzers passifs demandent un peu plus de travail que les buzzers actifs car ils ne génèrent pas de son seuls. Vous devez leur envoyer un signal en onde carrée à une fréquence spécifique pour produire une tonalité. Mais la fonction Arduino tone() facilite cela.

Voici un exemple simple qui joue une tonalité de 1 kHz pendant une seconde sur un buzzer passif connecté à la broche 11 :

int buzzerPin = 11;

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

void loop() {
  tone(buzzerPin, 1000);  // Play 1000 Hz tone
  delay(1000);            // Wait for 1 second
  noTone(buzzerPin);      // Stop the tone
  delay(1000);            // Wait for 1 second before repeating
}

Ce code configure la broche 11 en sortie et utilise tone() pour générer une onde carrée à 1000 Hz. Le buzzer sonne pendant une seconde, puis s’arrête pendant une seconde, créant un motif de bip.

Vous pouvez aussi créer des mélodies en changeant la fréquence et la durée. Par exemple, pour jouer deux notes différentes en séquence :

int buzzerPin = 11;

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

void loop() {
  tone(buzzerPin, 523);  // Play C5 note (523 Hz)
  delay(500);
  tone(buzzerPin, 659);  // Play E5 note (659 Hz)
  delay(500);
  noTone(buzzerPin);
  delay(1000);
}

Dans cet exemple, le buzzer joue une note C5 suivie d’une note E5, chacune durant une demi-seconde. La fonction noTone() arrête le son avant la pause.

Si vous voulez plus de contrôle, vous pouvez générer les tonalités manuellement avec digitalWrite() et delayMicroseconds(), mais tone() est généralement suffisant et plus simple à utiliser. Voici le même code qu’avant mais avec tone() remplacé :

int buzzerPin = 11;

void playTone(int frequency, int durationMs) {
  long halfPeriod = 1000000L / (2L * frequency);   
  long cycles = (long)frequency * durationMs / 1000L;

  for (long i = 0; i < cycles; i++) {
    digitalWrite(buzzerPin, HIGH);
    delayMicroseconds(halfPeriod);
    digitalWrite(buzzerPin, LOW);
    delayMicroseconds(halfPeriod);
  }
}

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

void loop() {
  playTone(523, 500);  // C5 (523 Hz) for 500 ms
  delay(10);           // Short pause between notes

  playTone(659, 500);  // E5 (659 Hz) for 500 ms
  delay(1000);         // Equivalent to noTone() + delay(1000)
}

Rappelez-vous, les buzzers passifs nécessitent un signal de fréquence pour produire du son, utilisez donc toujours tone() ou des méthodes équivalentes pour les piloter. Pour plus d’exemples, consultez notre Use A Piezo Buzzer With Arduino tutoriel.

Vous pouvez utiliser l’outil suivant pour trouver les fréquences et durées à passer à la fonction tone() pour jouer les sons souhaités :

Dépannage des problèmes courants

Lorsque vous travaillez avec des buzzers, vous pouvez rencontrer quelques problèmes courants. Heureusement, la plupart sont faciles à résoudre avec quelques vérifications et ajustements simples.

D’abord, si votre buzzer ne fait aucun son, commencez par vérifier votre câblage. Assurez-vous que les broches positive et négative du buzzer sont correctement connectées à la broche de sortie et à la masse de l’Arduino. Une polarité inversée peut empêcher le buzzer de fonctionner, surtout pour les buzzers actifs.

Ensuite, vérifiez votre code. Pour les buzzers actifs, un simple digitalWrite à HIGH devrait produire du son. Pour les buzzers passifs, vous devez utiliser la fonction tone() pour générer une fréquence. Si vous oubliez cela, le buzzer restera silencieux ou ne produira qu’un clic.

Si le buzzer émet un son faible ou déformé, le problème peut venir de votre alimentation. Assurez-vous que votre carte Arduino fournit assez de courant. Parfois, utiliser une source d’alimentation séparée ou ajouter un transistor pour piloter le buzzer aide.

Un autre problème est un bourdonnement continu alors que vous attendez des sons intermittents. Cela arrive généralement si votre code manque de temporisation ou de délais appropriés. Utilisez la fonction delay() ou des timers pour contrôler quand le buzzer s’allume et s’éteint.

Enfin, notez que vous ne pouvez pas régler le volume du buzzer via le code, qu’il soit passif ou actif. Cependant, vous pouvez ajouter une résistance en série à un buzzer passif pour réduire la tension et donc le volume dans une certaine mesure.

Conclusions

Les buzzers ajoutent du son et du feedback à vos projets Arduino de manière simple et efficace. Les buzzers actifs sont faciles à utiliser car ils n’ont besoin que d’alimentation pour produire du son. Il suffit de les connecter à une broche numérique et à la masse, puis de mettre la broche à HIGH pour entendre une tonalité. Les buzzers passifs, eux, demandent plus de contrôle. Vous devez générer un signal en onde carrée pour créer différentes tonalités, ce qui offre plus de flexibilité pour les mélodies et effets sonores.

Le choix du buzzer dépend des besoins de votre projet. Si vous voulez un bip rapide ou une alarme, un buzzer actif est le meilleur choix. Si vous souhaitez jouer des airs ou des sons personnalisés, optez pour un buzzer passif. Vérifiez toujours la fiche technique du buzzer pour confirmer son type et ses exigences en tension.

Lors de la connexion des buzzers à votre Arduino, pensez à utiliser des résistances de limitation de courant si nécessaire et évitez de les alimenter directement depuis des broches qui ne peuvent pas fournir assez de courant.

Si vous avez des questions, n’hésitez pas à les poser dans la section commentaires.

Bon bricolage 😉