Projets

Tutoriel – Un générateur de vent

Créé par

Garo

Publié le

22 décembre 2016

Modifié le

8 janvier 2017

Autre Niveau intermédiaire Création individuelle


 
 
Pour ce premier projet en langage de programmation Python, je souhaite créer un petit programme pouvant générer un bruit de vent complètement aléatoire. Ce son sera généré par seulement quatre objets différents : un générateur de bruit blanc, un module aléatoire, un filtre et un oscillateur de basse fréquence (LFO).
Pour ce faire, il faut installer le logiciel pyo, qui est développé à Montréal.
Cependant, avant de télécharger le logiciel pyo, il faut télécharger deux librairies Python, une pour les éléments graphiques et une pour le langage :

Télécharger et installer Python: https://www.python.org/download/releases/2.7.8/ (important de prendre la version 2.7.8)
télécharger et installer WxPython: https://www.wxpython.org/download.php

(Il est important de prendre la version 2.7)

Télécharger et installer pyo: http://ajaxsoundstudio.com/software/

Avant de continuer, il est important de mentionner que le langage de programmation python est un langage de programmation orienté objet. C’est-à-dire qu’il s’agit d’un langage de programmation ou nous sommes menés à faire interagir plusieurs objets ensemble : j’appelle un objet que j’imbrique dans un second objet, et j’imbrique ensuite ces deux objets dans un troisième objet, et ainsi de suite. C’est un langage relativement simple, contrairement au C++, qui est beaucoup plus complexe.

Ouvrir pyo;
Sous l’onglet File, sélectionner New From Template et Pyo Template. Il s’agit de notre interface et nous devons écrire nos lignes de codes entre les lignes :

5 – s = Server(sr=44100, nchnls=2, buffersize=512, duplex=1).boot()
et
10 – s.gui(locals())
Pyo est un outil puissant pour faire de la programmation Python. De plus, il s’agit d’un logiciel qui a été vigoureusement documenté par son créateur. Pour accéder à la documentation de pyo, vous pouvez sélectionner à partir de l’onglet View, Open Documentation Frame. Ou faire tout simplement Shift+Ctrl+D.
Pour la programmation en langage Python il est essentiel de toujours nommer nos objets avant de les appeler. C’est vraiment la base de n’importe quelle programmation en langage Python. Par exemple : a = Objet, b = Objet2, a1 = Objet3, etc.

Nous appelons notre premier objet: notre générateur de bruit blanc. Dans pyo, le générateur s’appelle Noise. Je vais nommer l’objet Wn (White Noise) et y associer le générateur Noise de cette manière :

Wn = Noise(0.1).out()
L’extension .out() est ce qui permet d’entendre le son généré par le générateur.
Chaque objet possède ses propres attributs et ces attributs seront toujours entre les deux parenthèses. Si nous n’écrivons aucune donnée, ce sera les valeurs par défaut. Le chiffre a l’intérieur des parenthèses sert à régler le volume. Ici, j’ai baissé le volume de manière à ce que le son ne nous déchire pas les tympans. Les attributs par défaut du générateur Noise sont : mul (l’amplitude, donc le volume) et add (on peut l’ignorer).

Maintenant, nous allons créer un objet aléatoire. Nous devrons donner une valeur minimale et une valeur maximale et l’objet ira piger des valeurs aléatoires entre ses deux valeurs définitives. L’objet aléatoire que nous allons utiliser s’appelle : Randi et nous allons l’utiliser sur notre futur oscillateur de basse fréquence (LFO). Je nomme l’objet rdmlfo = Randi(min=20, max=4000, freq=0.5).

La valeur minimale sera de 20;
La valeur maximale sera de 4000;
La fréquence de l’oscillateur sera de 0.5.

Ensuite, j’appelle un second objet aléatoire et celui-ci servira à établir les fréquences minimales et maximales de notre filtre. Je nomme l’objet rdmfilt1=Randi(min=50, max=500, freq=0.5)

La valeur minimale sera de 50Hz;
La valeur maximale sera de 5000Hz;
La fréquence d’oscillation des nouvelles valeurs sera de 0.5.

Nos deux objets aléatoires sont maintenant créés, l’avant-dernier objet à créer est l’oscillateur de basse fréquence (LFO). Un LFO envoie des fréquences tellement basses qu’elles font osciller le son. L’objet que nous allons utiliser s’appelle SineLoop et possède les attributs suivant : freq (fréquence d’oscillation, donc la rapidité), feedback(si nous voulons ajouté un effet de retour de distorsion), mul et add.

Je vais intégrer notre objet rdmlfo dans l’attribut freq du SineLoop. Je nomme mon objet comme ceci : lfo=SineLoop(freq=rdmlfo, mul=0.1)

Nous sommes maintenant rendus à la création du dernier objet du petit programme : le filtre. Nous allons utiliser le filtre Biquad, qui possède les attributs suivants : input (le son que nous voulons passer dans le filtre), freq (la fréquence que nous voulons supprimer/modifier), q (la précision du filtre), type (0=filtre passe-bas, 1=filtre passe-haut, 2=filtre passe-bande, 3=filtre stop-bande et 4=filtre passe-tout). J’écris l’objet de cette manière : filt1=Biquad(Wn, freq=rdmfilt1).out()

Pourquoi le .out() est à la fin de filt1=Biquad(Wn, freq=rdmfilt1) et non comme au début, soit à la fin de Wn=Noise(0.1)? Tout simplement parce que nous voulons entendre le son à la fin de la chaîne de traitement et non au début.
Nous écrivons le programme comme nous souhaitons l’entendre : on met un son, on y applique les effets et on veut entendre le résultat.

J’appuie sur les touches CTRL+R pour ouvrir la fenêtre d’activation du programme. En temps normal, il ne devrait pas y avoir d’erreur;
Par mesure de sécurité, il faut placer le potentiomètre de l’amplitude à 0dB et ensuite, on appuie sur Start. On monte graduellement le potentiomètre afin d’assurer un bon niveau sonore;

Voilà! Vous avez écrit votre premier programme en langage Python. Ce petit programme ne représente même pas 1% des possibilités du logiciel. Ces possibilités sont littéralement infinies.
#!/usr/bin/env python
# encoding: utf-8
from pyo import *
 
s = Server(sr=44100, nchnls=2, buffersize=512, duplex=1).boot()
 
Wn = Noise(0.1)
 
rdmlfo=Randi(min=20, max=4000, freq=0.5)
 
rdmfilt1=Randi(min=50, max=500, freq=0.8)
 
lfo=SineLoop(freq=rdmlfo, mul=0.1)
 
filt1=Biquad(Wn, freq=rdmfilt1, q=1).out()
 
s.gui(locals())
 
 

Comme je ne suis pas satisfait à 100% de mon programme, je peux continuer à ajouter des objets, afin de peaufiner mon bruit de vent numérique!

#!/usr/bin/env python
# encoding: utf-8
from pyo import *
 
s = Server(sr=44100, nchnls=2, buffersize=512, duplex=1).boot()
 
Wn = Noise(0.1)
 
rdmlfo=Randi(min=20, max=4000, freq=0.5)
 
rdmfilt1=Randi(min=50, max=500, freq=0.8)
rdmfilt2=Randi(min=60, max=600, freq=0.5)
rdmfilt3=Randi(min=20, max=1000, freq=0.6)
 
lfo=SineLoop(freq=rdmlfo, mul=0.1)
 
filt1=Biquad(Wn, freq=rdmfilt1, q=1).out()
filt2=Biquad(Wn, freq=rdmfilt2, q=2).out()
filt3=Biquad(Wn, freq=rdmfilt3, q=2).out()
s.gui(locals())

générateurmusiqueprogrammationprogrammepyopythonsquarevent

Inscription

Ce projet n'est inscrit à aucun concours pour le moment.

Commentaires

Laisser un commentaire

Tu dois être connecté pour laisser un commentaire.