(prise en charge par le protocole
”Firmata Express”)
Pour produire un son avec un Arduino, on utilise un petit haut‐parleur ou un buzzer (transducteur) piézo‐électrique (communément appelé ”piezo”) connecté sur une des sorties de l’Arduino comme ci-dessous :
En langage Arduino, Le signal électrique appliqué par le microcontrôleur sur une de ses sorties digitales ou analogiques, sur laquelle est connecté le piezo ou le haut‐parleur, est réalisé avec la fonction tone().
Cette fonction génère une onde carrée (onde symétrique avec « duty cycle » (niveau haut/période) à 50%) à la fréquence spécifiée en Hertz (Hz) sur une broche.
La durée peut être précisée, sinon l’impulsion continue jusqu’à l’appel de l’instruction noTone().
Avec ”pymata-express” pour utiliser une broche de l’Arduino en mode ”tone”, il faut au préalable la déclarer avec l’instruction :
loop.run_until_complete(board.set_pin_mode_tone(pin))
où :
– ”board” est l’objet créé lors de l’appel de la méthode ”PymataExpress” du module ”pymata-express”,
– ”pin” est le numéro de la broche du microcontrôleur sur laquelle est connecté le piezo ou le haut‐parleur,
– ”loop” est la boucle des tâches ”asyncio” déclarée ainsi :
loop = asyncio.get_event_loop()
On peut définir une fonction déclarant plus facilement une broche en mode ”tone” :
|
def Set_Tone_Pin(board,pin): loop.run_until_complete(board.set_pin_mode_tone(pin)) |
La syntaxe pour déclarer la broche N° 3 en mode ”tone” est alors plus simple :
Set_Tone_Pin(board,3)
Ensuite, on peut produire un son de fréquence ”F” en Hz pendant une durée ”D” en ms avec un piezo connecté sur la broche ”pin” au moyen de cette instruction :
loop.run_until_complete(board.play_tone(pin, F, D))
L’onde sonore peut être émise de façon continue :
loop.run_until_complete(board.play_tone_continuously(pin, F))
Le plus simple est de réunir les deux instructions dans une seule fonction dont les arguments sont le N° de la broche, la fréquence et la durée, puis d’utiliser l’une ou l’autre instruction en fonction de la valeur de la durée :
|
def Tone(board,pin,freq,duration): if duration>0: loop.run_until_complete(board.play_tone(pin, freq, duration)) else: loop.run_until_complete(board.play_tone_continuously(pin, freq)) |
Ainsi, la commande pour émettre un son, avec un piezo connecté à la broche N°3, à une fréquence de 440 Hz est :
– Pendant 1 s : Tone(board,3,440,1000)
– De façon continue : Tone(board,3,440,0)
Une onde sonore émise en continu est arrêtée avec l’instruction :
loop.run_until_complete(board.play_tone_off(pin))
où ”pin” est le numéro de la broche du microcontrôleur sur laquelle est connecté le piezo ou le haut‐parleur.
On définira une fonction utilisant cette instruction :
|
def No_Tone(board,pin): loop.run_until_complete(board.play_tone_off(pin)) |
Et pour arrêter l’émission sonore sur la broche N°3, l’instruction devient :
No_Tone(board,3)
Exemple :
Le programme d’application (”Tone.py”) suivant, émet un ”beep” sonore :
Déroulement du programme :
– Importation des librairies et définition de fonctions :
. Le module ”ConnectToArduino.py”, contenant les fonctions de connexion à l’arduino via le protocole ”Firmata Express”,
. La bibliothèque ”asyncio” nécessaire au fonctionnement de ”PymataExpress”,
. La bibliothèque ”time” pour la gestion des durées d’émission et de silence.
. Fonction vSet_Tone_Pin” pour déclarer une broche en mode ”Tone”,
. Fonction ”Tone” pour produire une onde sonore de fréquence fixée en Hz,
. Fonction ”No_Tone” pour arrêter l’émisssion sonore,
. Fonction ”Arduino_Exit” pour fermer le port COM et se déconnecter de l’Arduino.
– Déclaration des constantes et variables :
. PinTone = 3 (constante correspondant au n° de la broche sur laquelle le piezo est connecté)
. FreqTone = 440 (variable correspondant à la fréquence en Hz de l’onde sonore)
. TimeSleep1 = 0.5 (variable correspondant à la durée d’émission du son en s)
. TimeSleep2 = 0.5 (variable correspondant à la durée du silence en s)
. PortComArduino (port COM sur lequel l’Arduino est connecté)
– Connexion à l’Arduino :
. Détection du port COM :
PortComArduino = SelectPortCOM()
. Tentative d’ouverture du port COM sélectionné et connexion à l’Arduino:
board = OpenPortCom(PortComArduino)
. si la connexion à l’Arduino est réussie:
–> Définition d’une boucle asyncio :
loop = asyncio.get_event_loop()
–> Déclaration de la broche du piezo en mode ”Tone” :
Set_Tone_Pin(board, PinTone)
– Boucle principale du programme (boucle ”while True”) :
. Emission de l’onde sonore à la fréquence ”FreqTone” pendant ”TimeSleep1”,
. puis silence pendant ”TimeSleep2”,
. puis nouvelle émission,
. etc…
– Fin du programme en appuyant sur Ctrl-C :
–> Arrêt de l’émission sonore et le port série est fermé.
