Le buzzer piézo est un dispositif électronique qui peut être utilisé à la fois comme un capteur de son et de choc. Il est capable de détecter des sons et des vibrations à des niveaux très bas et peut être utilisé pour des applications variées. Il est très pratique et peut être facilement intégré à des systèmes électroniques. Dans cet article, nous allons examiner comment le buzzer piézo peut être utilisé comme capteur de son et de choc et quels sont les avantages et les inconvénients de cette technologie.
Utiliser un buzzer piézo en capteur de son/choc
(cliquer sur l’image pour agrandir)
1. Présentation
On réalise la mesure de la tension en provenance d’un buzzer piézo connecté sur la voie analogique A0
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise la conversion analogique numérique 10 bits
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.
2.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,
- des straps,
- un buzzer piézo-électrique
- une résistance 1/4w de 1 ou 2 Méga Ohms,
3. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
- Broche A0 : Buzzer piézo en parallèle avec une une résistance de 2 MegaOhms
4. Le schéma théorique du montage
4.1 Schéma 1 : le buzzer en parallèle avec une résistance de 2 Méga Ohms
Le schéma théorique du montage (cliquer pour agrandir)
5. Le circuit du montage
5.1 Montage 1 : le buzzer en parallèle avec une résistance de 2 Méga Ohms
Le schéma du montage à réaliser (cliquer pour agrandir)
6. Fonctionnement du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
Le déroulement du programme
7. Explication du programme
- La carte Arduino mesure la valeur de la tension en sortie du buzzer piézo et envoie la valeur vers l’interface Processing sur le PC
8. Mise en oeuvre du programme
8.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
8.2 Préparation du Terminal côté PC dans le logiciel Arduino
- Côté PC, il faut ouvrir la fenêtre terminal de l’IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
- La fenêtre « Terminal » s’ouvre alors :
- Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :
8.3 Fonctionnement
- Lancer l’interface Processing sur le PC et visualiser le résultat en tapant dans les mains ou en tapant à côté du buzzer
Résultats avec le montage 1 :
(cliquer sur l’image pour agrandir)
9. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// can_Graph_pc_v3
// par X. HINAULT – 03/2011
// wwww.mon-club-elec.fr
// — Que fait ce programme ? —
/* Envoie la valeur brute de la conversion analogique sur 6 voies, sur le port série
sous la forme « CAN=:val0:val1:val2:val3:val4:val5:=finCAN »
*/
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise la conversion analogique numérique 10bits sur les 6 voies analogiques
// — Circuit à réaliser —
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
// Broches analogiques : connecter les tension à mesurer sur les broches
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique
// — Déclaration des variables globales —
int mesure_brute=0;// Variable pour acquisition résultat brut de conversion analogique numérique
// — Initialisation des fonctionnalités utilisées —
//**************** FONCTION SETUP = Code d’initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter au démarrage —
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
} // fin de la fonction setup()
// ********************************************************************************
//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
// — ici instructions à exécuter par le programme principal —
//—- envoie sur le port série les 6 mesures sous la forme CAN=:val0:val1:val2:val3:val4:val5:=finCAN
//— les : sont utilisés comme séparateur par le programme Processing cté PC
Serial.print(« CAN=: »); // chaine de début
for (int i=0; i<6; i++) { // défile les vois analogiques
// acquisition conversion analogique-numerique (CAN) sur la voie analogique
mesure_brute=analogRead(Voie[i]);
// affiche valeur numerique entière ou à virgule au format décimal
Serial.print(mesure_brute);
Serial.print(« : »); // séparateur entre les valeurs
} // fin for i
Serial.println(« =finCAN »); // fin de la chaine + saut de ligne
delay(100); // fixe une pause entre 2 mesures
// plus le délai est court, plus la trace est rapide
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// — Fin programme —
