Arduino : buzzer et photorésistances!

[Dobry]

Cet article a été adapté depuis mon blog il est tout à fait possible des des erreurs s'y trouvent (je ne suis que profane dans ce domaine), n'hésitez donc pas à critiquer !

Au programme de ce deuxième article, il y a les ponts diviseurs de tension (et leur utilité), les photorésistances (résistance variable en fonction de l'intensité lumineuse), mais également les buzzers (pour faire du bruit !), en outre, encore des applications relativement simples, mais qui n'en restent pas moins ludiques et intéressantes.

Liste du matériel nécessaire:

• Des photorésistances (au moins 2)
  
• Des résistances (500 et 10k par exemple)
  
• Un buzzer
  
• Des fils
  

Le projet final de cet article est de créer un "clavier tactile" (photosensible), permettant de libérer différents sons (comme à chaque fois, les parties sont étudiées séparément, une à une, avant d'être rassemblées).

0x01] Le Matériel

Les photorésistances

Une photorésistance est une résistance variable (résistance photodépendante) qui varie en fonction de l'intensité de la lumière captée. La résistance de cette dernière diminue lorsque l'intensité lumineuse augmente.
Ainsi, nous pouvons utiliser ces photorésistances comme des capteurs lumineux, définir un seuil de luminosité et effectuer des actions en conséquence (en domotique, la gestion de l'intensité de l'éclairage dans une pièce par exemple).
Dans cet article, nous utiliserons ces photorésistances pour créer des touches "tactiles". En plaçant le doigt entre la source lumineuse et la résistance, il est possible de modifier brutalement l'intensité captée, et donc de déclencher une action en avale.
Les buzzers
Ce sont grossièrement des "haut-parleurs" qui vont donc nous permettre d'émettre des sons.
Pour cela, nous utiliserons la fonction tone(pin, frequency, duration) dont un exemple est disponible site officiel. Les buzzers, tout comme les LEDs possèdent une grande patte (+) et une petite (-).
L'utilisation d'un buzzer est donc ce qu'il y a de plus basique, un branchement (avec une petite résistance, disons 100ohm (comme sur le site Arduino)), une fonction Tone(), et le tour est joué !

Dans notre montage, nous aurons donc deux circuits, le premier avec une photorésistance, et dont nous pourrons lire la valeur à l'aide de la fonction analogRead (vous vous en souvenez ? J'en avais parlé dans mon premier article ).
Dans notre cas, l'anaogRead permet de lire une tension aux bornes d'un pin analogique (A0-A5), pour autant, nous ne pouvons pas lire directement la valeur à la sortie de notre photorésistance, pour cela, nous allons utiliser un pont diviseur de tension.
L'autre circuit est celui qui contrôlera le buzzer (ou les buzzers, nous verrons après pourquoi).

0x02] Ponts diviseurs de tension

Définition

Un pont diviseur de tension est un montage en série qui comme son nom l'indique, permet d'obtenir une tension plus faible, à partir d'une tension entrée.

Dans cet article, il sera constitué de deux résistances, R1 et R2.
La formule liée à une pont diviseur de tension est :
Vout = Vin* R2/(R1+R2), avec Vout et Vin en volt; R1 et R2 en Ohm.
Voici un schema du pont diviseur de tension que nous allons créer :

Utilité (dans le cadre de cet article)
Comme stipulé précédemment, nous aurons besoin de lire la valeur de la tension aux bornes de la photorésistance, et grâce à la formule énoncée ci-dessus, en connaissant Vout (mesuré par AnalogRead), Vin (3.3V ou 5V sur l'Arduino) et la valeur de R1 (ou de R2), c'est-à-dire une résistance connue, nous pourrons déterminer la valeur de la résistance variable (photorésistante).
Deux choix s'offrent à nous, dans le premier, nous envoyons directement la valeur de cette résistance, à travers la fonction map(value, fromLow, fromHigh, toLow, toHigh) au buzzer ce qui, en soit, risque de produire des sons relativement atroces et dont je voudrais nous protéger, ou alors, nous pouvons donner fréquence au buzzer, et activer ce dernier lorsque le seuil d'intensité lumineuse minimal (fixé) est dépassé (dans le sens inférieur), dans un but d'apprentissage, j'effectuerais les deux montages et les deux codes seront disponibles.
Lecture analogique sur diviseur
Connectons une première résistance, de 470ohm à la source 5V disponible sur l'Arduino, branchons également notre photorésistance de façon à créer ce pont diviseur de tension (ne pas oublier de relier la photorésistance au sol (GND)), branchons un fil en direction de l'entrée analogique n°0 au milieu du pont, ce qui devrait donner plus ou moins :

La valeur de la résistance de la photorésistance varie en fonction de la luminosité, il va de soit (d'après la formule énoncée plus haut) que la tension de sortie varie en même temps, c'est la valeur que nous devons lire sur l'entrée analogique n°0.

Exercice n°1
Histoire de s'habituer une nouvelle fois avec le transfert de données par la fonction Serial, nous allons afficher en temps réel la valeur de la photorésistance (on va faire un peu de mathématiques par la même occasion). Il s'agit premièrement d'isoler R2 dans la relation précédente, pour cela, je vous conseille de procéder à un double passage à l'inverse, on retrouve donc :
Vin/Vout = (R1+R2)/R2
(=) Vout/(Vin-Vout) = R2/R1
(=) R2 = (Vout*R1)/(Vin-Vout)

Les valeurs respectives de chaque variable sont :

• 5v pour Vin (ou 3.3 en fonction de l'alimentation que vous choisissez)
  
• R1, 470ohm, choisi arbitrairement
  
• AnalogRead() sur A0 pour connaitre Vout
  

Note : AnalogRead() fournit une valeur située entre 0 (0v) et 1024 (5v), il faut donc convertir Vout avant de l'utiliser dans la formule (sinon les résultats risquent d'être quelques peu étranges).
Pour faire cette transformation on utilise : Vout = (5*Vout)/1024
Vous l'aurez compris, le premier exercice consiste à écrire un code qui affiche sur la connexion serial la valeur de la photorésistance (en utilisant le montage précédent)

Code C :


    void setup(){
        Serial.begin(9600);
    }
    void loop(){
        float vout = analogRead(A0), vin = 5, r1 = 470, r2 = 0;
    vout = (5*vout)/1024;
    r2 = (vout*r1)/(vin-vout);
    Serial.println(r2);
    delay(250);
    }
 

Ici, on utilise des variables de type float pour éviter les imprecisions liées aux arrondis des rapports (imaginez les tronquages qui sont effectués lors de la division par 1024...). Rien de bien sorcier, juste un petit exercice histoire de reprendre les bases. Attention, la valeur affichée peut différer de la réalité (remplacez R2 par une résistance fixe connues) et être liée à de nombreuses incertitudes (celle de R1, de R2, de la lecture analogique, des arrondis et autres), mais elle permet cependant d'avoir une idée approximative de la valeur. Pour autant, en remplacant la photorésistance par une résistance de 470ohm elle aussi, la valeur affichée est tout à fait correct.
Maintenant que nous savons comment réaliser le premier circuit et récupéré la valeur de la résistance, il faut s'attaquer au second circuit, celui du buzzer, de même, ce montage reste tout ce qu'il y a de plus basique .

Circuit du buzzer
Une résistance de 100ohm, une buzzer, un pin rien de plus pour notre circuit, dont voici le schema :

Avant de finaliser le montage, voici un petit exercice mélodique histoire de découvrir un peu le fonctionnement du buzzer, le but est de jouer la gamme tempérée (do, ré, mi, fa, sol, la, si, do), vous pourrez trouver les fréquences de chaque note facilement sur wikipedia

Code C :


int buzzer = 7;
void setup(){
    pinMode(buzzer, OUTPUT);
}

void loop(){
    float frequences[] = {261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25};
    for(int i=0; i<8; i++){
        tone(buzzer, frequences[i]);
        delay(1000);
    }
}
 

Les plus curieux (ou instruits) auront deviné que la résistance ne modifie que l'intensité du son, plus la résistance sera élevée, plus le son produit sera faible, modifiez la résistance par un photorésistance, et plus l'intensité lumineuse sera élevée, plus l'intensité sonore sera elle aussi importante (cela pourrait être un début de système permettant de jouer une musique lorsque vous allumez la lumière de la pièce par exemple). Maintenant que nous avons nos deux circuits, nous allons fusionner les deux afin de n'en faire plus qu'un ! Mais avant cela, il nous manque un dernier ingrédient avant d'éviter que le son se repete en boucle.
Voici une illustration de cette merveilleuse gamme jouée par un buzzer de piètre qualité

Seuil d'intensité
Il s'agit ici de définir un seuil de luminosité (grâce à la tension lue sur l'entrée analogique) en dessous du quel le buzzer devra être activé (sinon la photorésistance n'est d'aucune utilité), dans un premier temps, je pense que le plus simple et de re-faire le premier montage (pont diviseur de tension, avec une résistance et une photorésistance), de regarder les valeurs de la tension (pas besoin de s'embeter avec la formule) puis de masquer la lumière en placant votre doigt au dessus de la photorésistance, et de re-noter la valeur affichée, puis de définir une variable qui représentera le seuil à dépasser pour activer le son. Cette méthode est un peu crade et pas portable (l'intensité dépendra du milieu et il faudra le changer à chaque modification de la luminosité (extérieur, nouvelle lampe)). Cependant, on pourrait considérer une autre méthode qui consiste à faire un circuit avec un bouton, et de déclancher la determination du seuil lorsque ce dernier est pressé. Pour autant, je n'ai toujours pas detaillé le fonctionnement des boutons, et je souhaite garder ce sujet pour un prochain article, sans le bacler, mais ne vous inquietez pas, lorsqu'il sera temps, je reviendrai sur cette article afin de présenter le montage complet !

Fusion !

Pour ce qui est du montage, c'est un assemblage des deux précédents, ce qui nous donne :

Je serais prêt à parier que vous aviez trouvé !
Comme ce que j'avais annoncé au début de l'article, nous allons utiliser ce montage de deux facons, la première avec la fonction map(value, fromLow, fromHigh, toLow, toHigh) afin de transformer les valeurs de la résistances (ou de la tension, ce qui nous évite les calculs) en fréquence audibles (mais loin d'être charmantes ), voici donc le code, suivi d'une vidéo

Code C :


int buzzer = 7, res = A5, seuil = 800, duree = 500;
int res    = A0;
void setup(){
    pinMode(buzzer, OUTPUT);
}
void loop(){
    int tension = analogRead(res), frequence;
    if(tension > seuil){
        frequence = map(tension, 0, 1024, 260, 525);
        tone(buzzer, frequence);
        delay(duree);
        noTone(buzzer);
    }
}
 

Tout d'abord, il faut déterminer si la valeur lue est supérieur au seuil arbitraire puis comme nous savons que les valeurs lues par l'entrée analogique varient entre 0 et 1024 et que nous voulons obtenir des fréquences situées entre 260Hz et 525 Hz, on passe ces paramètres à la fonction map. Le reste du code ne change pas, si ce n'est la fonction noTone() qui permet d'arreter le buzzer après qu'il ai sonné (sans quoi le buzzer continuera de sonner sans s'arreter avec un fréquence égale à la dernière fréquence connue).
L'autre montage que je vous avez proposé de réaliser est un montage attribuant une fréquence précise à une photorésistance, et de ne jouer cette dernière que si le seuil est depassé. Afin que ce projet soit plus interessant, j'utiliserai 2 photorésistances, une sur le pin analogique A0 et l'autre sur le A2 (les deux autres résistances ne changent pas : 470ohm) voici le code :

Code C :


int buzzer = 7, seuil = 800, duree = 1000;
int photores[] = {A0, A2};
float frequences[] = {261.63, 293.66}; // Fréquence attribué à chaque capteur
void setup(){
    pinMode(buzzer, OUTPUT);
}

void loop(){
    for(int i = 0; i< 2; i++){ // On parcours nos différentes photorésistances
        int tension = analogRead(photores[i]), frequence;
        if(tension > seuil){
            tone(buzzer, frequences[i]);
            delay(duree);
            noTone(buzzer); // pareil que tout à l'heure, il faut penser à arreter le buzzer.
        }    
    }
    delay(100);
}
 

Etant donnée que je suis quelqu'un de sympathique, voici une vidéo illustrant le montage final de cet article :

[Swissky]

Excellent tutoriel ; merci beaucoup