Note
Bonjour et bienvenue dans la communauté des passionnés de Raspberry Pi, Arduino et ESP32 de SunFounder sur Facebook ! Plongez dans l’univers du Raspberry Pi, Arduino et ESP32 avec d’autres passionnés.
Pourquoi nous rejoindre ?
Support d’experts : Résolvez les problèmes après-vente et relevez les défis techniques grâce à l’aide de notre communauté et de notre équipe.
Apprenez & Partagez : Échangez des astuces et des tutoriels pour améliorer vos compétences.
Aperçus exclusifs : Accédez en avant-première aux annonces de nouveaux produits et à des avant-premières exclusives.
Réductions spéciales : Profitez de réductions exclusives sur nos nouveaux produits.
Promotions festives et concours : Participez à des concours et à des promotions spéciales pendant les fêtes.
👉 Prêt à explorer et créer avec nous ? Cliquez sur [Ici] et rejoignez-nous dès aujourd’hui !
21. Son de Sirène
Dans ce projet Arduino, nous allons explorer comment créer un système de sirène en programmant et en intégrant du matériel électronique.
Les sons de sirène utilisent un motif spécifique de fréquences et de hauteurs, caractérisé par des montées et descentes rapides des hauteurs, ce qui les rend facilement reconnaissables et distincts des autres sons du quotidien. Ces variations de hauteur peuvent provoquer un sentiment d’urgence, car elles sont souvent associées à des signaux d’avertissement ou à des situations dangereuses dans la nature.
En ajustant la fréquence d’un buzzer passif, nous pouvons simuler les montées et descentes caractéristiques d’une sirène.
Dans cette leçon, vous apprendrez :
Comment fonctionnent les buzzers passifs
Comment piloter un buzzer passif en utilisant la fonction tone()
Comment utiliser la boucle for en programmation
Comment implémenter un son de sirène
Comprendre les propriétés du son
Le son est un phénomène ondulatoire qui se propage à travers des milieux comme l’air, l’eau ou les solides sous forme d’énergie vibratoire. Comprendre les propriétés physiques du son peut nous aider à mieux comprendre et contrôler son comportement dans différents environnements. Voici plusieurs propriétés physiques clés du son :

Fréquence
La fréquence fait référence au nombre de cycles de vibration par unité de temps, généralement exprimée en Hertz (Hz). La fréquence détermine la hauteur du son : des fréquences plus élevées produisent des sons plus aigus ; des fréquences plus basses produisent des sons plus graves. La plage audible pour l’humain est d’environ 20 Hz à 20 000 Hz.
Amplitude L’amplitude est l’intensité de la vibration d’une onde sonore, et elle détermine le volume du son. Une plus grande amplitude signifie un son plus fort ; une amplitude plus faible signifie un son plus doux. En physique, l’amplitude est généralement directement liée à l’énergie d’une onde sonore, tandis que dans le langage courant, nous utilisons souvent les décibels (dB) pour décrire l’intensité sonore.
Timbre Le timbre décrit la texture ou le « coloris » du son, qui nous permet de distinguer les sons provenant de différentes sources même s’ils ont la même hauteur et la même intensité. Par exemple, même si un violon et un piano jouent la même note, nous pouvons toujours les distinguer grâce à leur timbre.
Dans ce projet, nous explorerons uniquement l’influence de la fréquence sur le son.
Construction du circuit
Composants nécessaires
1 * Arduino Uno R3 |
1 * Plaque d’essai |
1 * Buzzer passif |
Fils de connexion |
1 * Câble USB |
|||
Étapes de construction
Dans les leçons précédentes, nous avons utilisé un buzzer actif. Dans cette leçon, nous utiliserons un buzzer passif. Le circuit reste le même, mais la manière de le contrôler via le code est différente.
Localisez un buzzer passif, qui a un circuit imprimé visible à l’arrière.

Bien qu’il y ait un signe “+” sur le buzzer passif, il ne s’agit pas d’un composant polarisé. Insérez-le dans n’importe quelle direction dans les trous 15F et 18F de la plaque d’essai.

Connectez une broche du buzzer passif à la broche GND de l’Arduino Uno R3.

Connectez l’autre broche du buzzer passif à la broche 5V de l’Arduino Uno R3. Le buzzer ne produira aucun son, contrairement à un buzzer actif qui émettrait un son lorsqu’il est connecté de cette manière.

Maintenant, retirez le fil inséré dans la broche 5V et insérez-le dans la broche 9 de l’Arduino Uno R3, afin que le buzzer puisse être contrôlé par le code.

Création du code - Faire sonner le buzzer passif
Comme nous l’avons appris en connectant, il ne suffit pas d’appliquer une alimentation haute et basse à un buzzer passif pour le faire sonner. En programmation Arduino, la fonction tone()
est utilisée pour contrôler un buzzer passif ou d’autres dispositifs audio afin de générer un son à une fréquence spécifiée.
tone()
: Génère une onde carrée de la fréquence spécifiée (avec un cycle de 50 %) sur une broche. Une durée peut être spécifiée, sinon l’onde continue jusqu’à un appel ànoTone()
.Syntaxe
tone(pin, frequency)
tone(pin, frequency, duration)
Paramètres
pin
: la broche Arduino sur laquelle générer le son.
frequency
: la fréquence du son en Hertz. Types de données autorisés : unsigned int.
duration
: la durée du son en millisecondes (facultatif). Types de données autorisés : unsigned long.
- Retourne
Aucun résultat
Ouvrez l’IDE Arduino et démarrez un nouveau projet en sélectionnant « New Sketch » dans le menu « Fichier ».
Enregistrez votre sketch sous le nom
Lesson21_Tone
en utilisantCtrl + S
ou en cliquant sur « Enregistrer ».Commencez par définir la broche du buzzer.
const int buzzerPin = 9; // Assigne la broche 9 à la constante pour le buzzer
void setup() {
// Mettez ici votre code de configuration, exécuté une seule fois :
}
Pour comprendre pleinement l’utilisation de la fonction
tone()
, nous l’écrivons dans levoid setup()
afin que le buzzer émette un son à une fréquence spécifique pendant une durée définie.
const int buzzerPin = 9; // Assigne la broche 9 à la constante pour le buzzer
void setup() {
// Mettez ici votre code de configuration, exécuté une seule fois :
tone(buzzerPin, 1000, 100); // Allumer le buzzer à 1000 Hz pendant une durée de 100 millisecondes
}
void loop() {
// Mettez ici votre code principal, exécuté en boucle :
}
Vous pouvez maintenant téléverser le code sur l’Arduino Uno R3, après quoi vous entendrez un bref « bip » du buzzer passif, puis il se taira.
Questions
Si vous changez le code et connectez le buzzer aux broches 7 ou 8, qui ne sont pas des broches PWM, le buzzer émettra-t-il encore un son ? Vous pouvez tester et noter votre réponse dans le carnet.
Pour explorer comment
frequency
etduration
danstone(pin, frequency, duration)
affectent le son du buzzer, veuillez modifier le code dans deux conditions et remplir les phénomènes observés dans votre carnet :
En gardant
frequency
à 1000, augmentez progressivementduration
, de 100, 500 à 1000. Comment le son du buzzer change-t-il et pourquoi ?En gardant
duration
à 100, augmentez progressivementfrequency
, de 1000, 2000 à 5000. Comment le son du buzzer change-t-il et pourquoi ?
Création du code - Émettre un son de sirène
Précédemment, nous avons appris à faire émettre un son à un buzzer et à comprendre comment la fréquence et la durée influencent le son. Maintenant, si nous voulons que le buzzer émette un son de sirène qui monte d’un ton bas à un ton élevé, comment devrions-nous procéder ?
D’après nos explorations précédentes, nous savons que l’utilisation de la fonction tone(pin, frequency)
permet à un buzzer passif d’émettre un son. En augmentant progressivement la fréquence
, la hauteur du son du buzzer passif devient plus aiguë. Implémentons cela avec du code maintenant.
Ouvrez le sketch que vous avez sauvegardé précédemment,
Lesson21_Tone
.Cliquez sur “Enregistrer sous…” dans le menu “Fichier”, et renommez-le en
Lesson21_Siren_Sound
. Cliquez sur « Enregistrer ».Écrivez la fonction
tone()
dans la bouclevoid loop()
et définissez trois fréquences différentes. Pour entendre clairement la différence entre chaque fréquence, utilisez la fonctiondelay()
pour les séparer.
const int buzzerPin = 9; // Assigne la broche 9 à la constante pour le buzzer
void setup() {
// Mettez ici votre code de configuration, exécuté une seule fois :
}
void loop() {
// Mettez ici votre code principal, exécuté en boucle :
tone(buzzerPin, 100); // Allumer le buzzer à 100 Hz
delay(500);
tone(buzzerPin, 300); // Allumer le buzzer à 300 Hz
delay(500);
tone(buzzerPin, 600); // Allumer le buzzer à 600 Hz
delay(500);
}
À ce stade, vous pouvez téléverser le code sur l’Arduino Uno R3, et vous entendrez le buzzer émettre trois sons différents à répétition.
Pour obtenir une montée en fréquence plus fluide, nous devrions définir des intervalles plus courts pour la
fréquence
, par exemple un intervalle de 10, en commençant de 100, 110, 120… jusqu’à 1000. Nous pouvons écrire le code suivant.
void loop() {
// Mettez ici votre code principal, exécuté en boucle :
tone(buzzerPin, 100); // Allumer le buzzer à 100 Hz
delay(500);
tone(buzzerPin, 110); // Allumer le buzzer à 110 Hz
delay(500);
tone(buzzerPin, 120); // Allumer le buzzer à 120 Hz
delay(500);
tone(buzzerPin, 130); // Allumer le buzzer à 130 Hz
delay(500);
tone(buzzerPin, 140); // Allumer le buzzer à 140 Hz
delay(500);
tone(buzzerPin, 150); // Allumer le buzzer à 150 Hz
delay(500);
tone(buzzerPin, 160); // Allumer le buzzer à 160 Hz
delay(500);
...
}
Vous remarquerez que si vous souhaitez réellement monter jusqu’à 1000, ce code ferait plus de deux cents lignes. À ce stade, vous pouvez utiliser l’instruction
for
, qui est utilisée pour répéter un bloc d’instructions entre des accolades.for
: L’instructionfor
est utile pour toute opération répétitive et est souvent utilisée en combinaison avec des tableaux pour opérer sur des ensembles de données/broches. Un compteur d’incrémentation est généralement utilisé pour répéter et terminer la boucle.
Syntaxe
for (initialization; condition; increment) { // instruction(s); }
Paramètres
initialization
: se produit une seule fois au début.condition
: chaque passage dans la boucle teste cette condition ; si elle est vraie, le bloc d’instructions et l’incrémentation sont exécutés, puis la condition est testée à nouveau. Quand elle devient fausse, la boucle se termine.increment
: s’exécute à chaque passage de la boucle lorsque la condition est vraie.

Modifiez maintenant la fonction
void loop()
comme indiqué ci-dessous, oùfreq
commence à 100 et augmente de 10 jusqu’à 1000.
void loop() {
// Augmenter progressivement la hauteur
for (int freq = 100; freq <= 1000; freq += 10) {
tone(buzzerPin, freq); // Émettre un son
delay(20); // Attendre avant de changer la fréquence
}
}
Ensuite, faites en sorte que
freq
commence à 1000 et diminue de 10 jusqu’à 100, afin que vous puissiez entendre le son du buzzer monter puis descendre, simulant ainsi un son de sirène.
void loop() {
// Augmenter progressivement la hauteur
for (int freq = 100; freq <= 1000; freq += 10) {
tone(buzzerPin, freq); // Émettre un son
delay(20); // Attendre avant de changer la fréquence
}
// Diminuer progressivement la hauteur
for (int freq = 1000; freq >= 100; freq -= 10) {
tone(buzzerPin, freq); // Émettre un son
delay(20); // Attendre avant de changer la fréquence
}
}
Voici votre code complet. Vous pouvez maintenant cliquer sur « Téléverser » pour charger le code sur l’Arduino Uno R3.
const int buzzerPin = 9; // Assigner la broche 9 à la constante pour le buzzer
void setup() {
// Mettez ici votre code de configuration, exécuté une seule fois :
}
void loop() {
// Augmenter progressivement la hauteur
for (int freq = 100; freq <= 1000; freq += 10) {
tone(buzzerPin, freq); // Émettre un son
delay(20); // Attendre avant de changer la fréquence
}
// Diminuer progressivement la hauteur
for (int freq = 1000; freq >= 100; freq -= 10) {
tone(buzzerPin, freq); // Émettre un son
delay(20); // Attendre avant de changer la fréquence
}
}
Enfin, n’oubliez pas d’enregistrer votre code et de ranger votre espace de travail.
Résumé
Dans cette leçon, nous avons exploré comment utiliser un Arduino et un buzzer passif pour simuler un son de sirène. En discutant des propriétés physiques de base du son, telles que la fréquence et la hauteur, nous avons appris comment ces éléments influencent la perception et l’effet du son. À travers des activités pratiques, nous avons non seulement appris à construire des circuits, mais aussi maîtrisé la programmation avec la fonction tone()
sur Arduino pour contrôler la fréquence et la durée du son, réussissant ainsi à simuler un son de sirène qui monte et descend en hauteur.