Différences entre les versions de « ERG::livecoding »

De {}
Aller à la navigation Aller à la recherche
 
(65 versions intermédiaires par 2 utilisateurs non affichées)
Ligne 41 : Ligne 41 :
  
 
[[Fichier:livcod.jpg]]
 
[[Fichier:livcod.jpg]]
 +
 +
Dans un premier temps, nous allons d'abord nous concentrer sur la partie de droite, la captation et l'enregistrement de sons. Cette partie du programme peut être écrite en C et ne concernera que les RasberryPi.
 +
 +
1. Trouver une bibliothèque C permettant de se connecter à un micro et d'exporter de l'audio
 +
[https://khayyam.developpez.com/articles/cpp/fmodex/ FmodEx]
 +
 +
== Session du 05/11/2018 ==
 +
Justine, Danaé
 +
 +
[[Fichier:microhp.gif]]
 +
 +
L'objectif est d'envoyer à l'ordinateur une information numérique semblable à la grandeur physique que le microphone doit acquérir (ici enregistrer un son).
 +
 +
 +
class ofApp : public ofBaseApp {
 +
  // ... other things ...
 +
  void audioOut( float * output, int bufferSize, int nChannels );
 +
  double phase;
 +
};
 +
 +
void ofApp::setup() {
 +
  phase = 0;
 +
  ofSoundStreamSetup(2, 0); // 2 output channels (stereo), 0 input channels
 +
}
 +
 +
void ofApp::audioOut( float * output, int bufferSize, int nChannels ) {
 +
  for(int i = 0; i < bufferSize * nChannels; i += 2) {
 +
    float sample = sin(phase); // generating a sine wave sample
 +
    output[i] = sample; // writing to the left channel
 +
    output[i+1] = sample; // writing to the right channel
 +
    phase += 0.05;
 +
  }
 +
}
 +
 +
==Session du 26/11/2018==
 +
Justine, Danaé
 +
 +
Enregistre un fichier texte dans le dossier "bin" du projet.
 +
 +
#include <iostream>
 +
#include <fstream>
 +
using namespace std;
 +
 +
int main()
 +
{
 +
    ofstream myfile("example.txt",ios::app);
 +
    cout<<myfile.tellp()<<endl;
 +
    myfile.seekp(24, ios::end);
 +
    cout<<myfile.tellp()<<endl;
 +
    myfile<<"Premier essai";
 +
}
 +
 +
[[Fichier:RegisterTxt.png]]
 +
 +
 +
 +
 +
Par contre si la phrase est effacée, remplacé et le code à nouveau exécuté, le fichier "example.txt" n'est pas remplacé, mais les phrases s'écrivent à la suite.
 +
 +
[[Fichier:EcrisSuite.png]]
 +
 +
==Session du 10/12/2018==
 +
Justine
 +
----
 +
 +
==01/ Hello World, I'm SuperCollider==
 +
----
 +
 +
Lors de l’apprentissage d’un nouveau langage de programmation, la coutume veut que l’on commence par un programme simple appelé «Hello World». Cela affiche le texte 'Hello World!' partout où le programme devra afficher du texte. En SC, cet endroit est appelé la fenêtre de publication ('post window' en anglais). La fenêtre de publication est démarrée lorsque vous avez lancé SC pour la première fois. Un tas de choses y ont été affichées, et ressemblent à ceci :
 +
 +
    init_OSC
 +
    compiling class library..
 +
    NumPrimitives = 587
 +
    compiling dir: '/Applications/SC3/SCClassLibrary'
 +
    pass 1 done
 +
    Method Table Size 3764776 bytes
 +
    Number of Method Selectors 3184
 +
    Number of Classes 1814
 +
    Number of Symbols 7595
 +
    Byte Code Size 180973
 +
    compiled 296 files in 1.34 seconds
 +
    compile done
 +
    RESULT = 256
 +
    Class tree inited in 0.14 seconds
 +
 +
Ne vous inquiétez pas trop de ce que tout cela signifie pour le moment, gardez simplement à l’esprit que c’est là où SC vous enverra des informations. C'est également là que nous aurons le résultat de notre programme 'Hello World', que vous pouvez voir ci-dessous :
 +
 +
  "Hello World".postln;
 +
 +
Pour l'exécuter, cliquez simplement pour placer le curseur quelque part sur la même ligne que le code puis appuyez sur '''Maj-Entrée'''. Essayez maintenant.
 +
 +
Si tout se passe bien, vous devriez voir ceci dans la fenêtre de publication :
 +
 +
  Hello World!
 +
  -> Hello World!
 +
 +
Sinon, vous pouvez également sélectionner le code que vous souhaitez exécuter, puis appuyer sur Ctrl-Entrée.
 +
 +
Examinons maintenant le code de plus près. Le premier fragment, "Hello World!", est une sorte d'objet, appelé une '''chaîne ('string' en anglais)'''. Un objet est fondamentalement un moyen de représenter quelque chose sur l'ordinateur, par exemple un morceau de texte ou un oscillateur, qui vous permet de le contrôler et de lui envoyer des messages. Plus d’informations à ce sujet plus tard, mais pour l’instant, il suffit de comprendre qu’une chaîne est un moyen de représenter un peu de texte.
 +
Le second fragment, .postln;, dit « affiche-moi (ou une description explicite de moi) dans la fenêtre de publication ».
 +
 +
Rappelez-vous '''postln est votre ami'''. Vous pouvez l'appliquer à presque tout dans SC et obtenir quelque chose de significatif en retour. Cela peut être très pratique lorsque vous recherchez des bugs dans votre code.
 +
 +
Pourquoi l’a-il imprimé deux fois ? Eh bien, lorsque vous exécutez du code dans SC, il affiche toujours '''le résultat du dernier fragment de code''' (la dernière instruction). Donc, il imprime en premier lieu parce que nous lui avons explicitement dit d'imprimer, puis il affiche le résultat de cette opération, qui se trouve être la même chose dans ce cas-ci.
 +
Donc ici, nous n’avions pas vraiment besoin du fragment postln. Mais dans l'exemple suivant, cela nous sera utile. Copiez les deux lignes de texte suivantes, puis exécutez-les, en appuyant sur Maj-Entrée.
 +
 +
  "Hello there, I'm SuperCollider!".postln;
 +
  "Hello World!".postln;
 +
 +


La première ligne, 'Hello there, I'm SuperCollider!' n'aurait pas été imprimé si nous n'avions pas déclaré le postln.
 +
En général, lorsque vous êtes censé exécuter plusieurs lignes de code en même temps, elles seront entourées de parenthèses, comme dans l'exemple ci-dessous. Vous pouvez placer votre curseur n'importe où dans cette région (ou sur la ligne des parenthèses sur le Mac), puis double-cliquez et appuyez sur Ctrl-Entrée ou Maj-Entrée - ceci sélectionne toute la région et l'exécute. Essayez-le sur l'exemple ci-dessous.
 +
 +
  (
 +
  "Hello there, I'm SuperCollider!".postln;
 +
  "Hello World!".postln;
 +
  )
 +
 +
Fenêtre de publication :
 +
  Hello there, I'm SuperCollider!
 +
  Hello World!
 +
  -> Hello World!
 +
 +
Un double-clic à l’intérieur d’une paire de parenthèses englobantes peut ne pas sélectionner toute la zone dans certains systèmes, notamment sur les Mac modernes. Pour certains, cela ne sélectionne que le mot double-cliqué. Ainsi, il peut être utile de prendre l'habitude de toujours vérifier que vous avez sélectionné tout le code souhaité, quelle que soit la technique de sélection, avant d'appuyer sur Ctrl-Entrée ou sur Maj-Entrée. Faites des essais pour savoir comment votre système se comporte.
 +
Lorsque le code n'est pas entouré de parenthèses, il est généralement destiné à être exécuté ligne par ligne. Vous pouvez placer votre curseur n'importe où dans une ligne de code et appuyer sur les touches Ctrl-Entrée ou Maj-Entrée pour sélectionner la ligne entière et l'exécuter.
 +
Notez que chacune des lignes du bloc de code se termine par un point-virgule. Ceci est très important lorsque vous exécutez plusieurs lignes de code.
 +
De plus, la fenêtre de publication devient parfois pleine de choses difficiles à lire. '''Vous pouvez l’effacer à tout moment en appuyant sur Cmd-shift-p''' (maintenez la touche Commande et la touche Maj enfoncées, puis appuyez sur p).
 +
 +
== Live coding SON ==
 +
Danaé
 +
 +
Télécharger le programme [https://sonic-pi.net SonicPi ], destiné au live coding de son uniquement; très pratique car il comprend un tutoriel clair et complet, ce qui permet de tester les choses au fur-et-à-mesure qu'on les découvre.
 +
 +
Un exemple d'utilisation [https://www.youtube.com/watch?v=a1RxpJkvqpY ici]
 +
Et encore ici, par le créateur même de sonic pi [https://www.youtube.com/watch?v=KJPdbp1An2s Sam Aaron]
 +
 +
[https://fr.yamaha.com/files/download/other_assets/5/330245/moxf6moxf8_synth_fr_pm_a0.pdf Un manuel d'utilisation de synthétiseurs], dont certains chapitres aident à comprendre quels sont les paramètres d'un son, et du coup comment on peut les modifier et les créer par la suite, avec sonic Pi par exemple. Le manuel est assez technique alors nous allons reprendre les principales caractéristiques d'une onde sonore ci-dessous :
 +
 +
[[Fichier:onde.png]]
 +
 +
*A :Key On : Pression de la touche
 +
*B. Key Off : Relâchement de la touche
 +
*C : temps
 +
*D : Hauteur de ton
 +
*E : Hold time
 +
*F : Attack time
 +
*G : Decay 1 time
 +
*H : Decay 2 time
 +
*I : Release time
 +
*J : hold level
 +
*K : attack level
 +
*L : decay 1 level
 +
*M : decay 2 level = sustain level
 +
*N : release level
 +
 +
[[Fichier:description.png]]
 +
 +
Dans Sonic Pi, tous ces paramètres sont visibles dans la partie "Echantillons", il y a également une description de chacun d'eux, etc.
 +
 +
==Session du 18/12/2018==
 +
Justine
 +
 +
==02/ Le monde selon SuperCollider==
 +
----
 +
 +
SuperCollider est en réalité trois programmes:
 +
* l'éditeur de texte (ou IDE),
 +
* le langage (sclang ou application 'client'),
 +
*  et le serveur, qui effectue la synthèse et le calcul de l'audio.
 +
 +
La partie sclang est un langage de programmation sophistiqué avec d’agréables fonctionnalités d'interface graphique; et la partie serveur est une application de ligne de commande UNIX simple, légère et efficace (ce qui signifie qu’elle s’exécute sans représentation graphique).
 +
Ils communiquent via un protocole appelé Open Sound Control (OSC), via UDP ou TCP, protocoles réseau également utilisés sur Internet. Ne pensez donc pas que les deux applications doivent fonctionner sur des ordinateurs différents (elles peuvent le faire, ce qui peut présenter des avantages évidents en termes de performances), ou qu'elles doivent être connectées à Internet (bien qu'il soit possible d'avoir des clients et des serveurs dans différentes parties du monde communiquant !!). La plupart du temps, ils fonctionneront sur la même machine.
 +
 +
Le langage de l’application dispose de nombreux objets puissants qui représentent des éléments sur le serveur et vous permettent de les contrôler facilement. Comprendre comment cela fonctionne est crucial pour maîtriser SC, nous en parlerons donc de manière plus approfondie.
 +
 +
Mais d'abord amusons-nous un peu et faisons du son ...
 +
 +
=== [Exercice suggéré] ===
 +
 +
Ouvrez une nouvelle fenêtre en appuyant sur Ctrl-N (Cmd-N sur Mac) ou choisissez "New" dans le menu "File". Enregistrez le document en lui donnant un nom tel que "premierCodeSC.scd". Notez que vous devez toujours utiliser l'extension '.scd' pour les fichiers contenant du code SC.
 +
 +
  x = {SinOsc.ar(MouseX.kr(100,500))}.play
 +
  x.free //pour arrêter le son
 +
 +
Copiez quelques exemples de code ci-dessus, ou celui ci-dessous, et collez-les dans le nouveau document (les raccourcis standard Ctrl-C et Ctrl-V (Cmd-C et Cmd-V sur Mac) fonctionnent pour copier-coller ou utilisez le menu Edit). Essayez de modifier le texte entre les guillemets pour imprimer différentes choses dans la fenêtre de publication.
 +
 +
SC vous permettra de modifier les fichiers d’aide et la documentation. C’est donc une bonne idée de copier du texte avant de le modifier afin d’éviter de sauvegarder accidentellement des fichiers modifiés !
 +
 +
==03. Lancez les moteurs !==
 +
 +
Avant de pouvoir émettre un son, nous devons démarrer ou «initialiser» (boot) une application serveur. Le moyen le plus simple consiste à utiliser le raccourci Ctrl-B (Cmd-B sur Mac). Il existe également un menu « Server » dans lequel on peut utiliser "Boot Server » pour démarrer les paramètres audio.
 +
 +
 +
[[Fichier:Boot0.png]]
 +
 +
[[Fichier:Boot1.png]]
 +
 +
Notez que la police blanche sur la vue noire au bas de la fenêtre a été changée en vert. Cela indique que le serveur est en cours d'exécution. La vue fournit également des informations sur l'utilisation du processeur et d'autres éléments qui ne sont probablement pas encore clairs. Plus à ce sujet bientôt.
 +
 +
 +
Jetez également un coup d'œil à la fenêtre de publication, où SC vous a donné des informations, et vous indique qu'il a bien démarré :
 +
 +
[[Fichier:PostbootOK.png]]
 +
 +
 +
Si, pour une raison quelconque, le démarrage échouait, des informations l’indiqueraient.
 +
Par défaut, vous pouvez faire référence au serveur localhost dans votre code en utilisant la lettre s. Vous pouvez donc envoyer des messages pour le démarrer et l’arrêter ainsi:
 +
  s.quit;
 +
  s.boot;
 +
 +
Essayez ceci et laissez le serveur en marche. De nombreux exemples dans la documentation incluent s.boot au début, mais en général vous devez vous assurer que le serveur est en marche avant d'utiliser des exemples qui génèrent de l'audio, ou accéder au serveur. En général, les exemples de ce tutoriel supposent que le serveur est en cours d'exécution.
 +
 +
Vous pouvez également faire référence au serveur localhost avec le texte Server.local, par exemple:
 +
  Server.local.boot;
 +
 +
==04. Fonctions et autres fonctionnalités==
 +
 +
Le moyen le plus simple d'obtenir du son depuis SC est d'utiliser une fonction. Vous trouverez ci-dessous un exemple simple. Exécutez-le après vous être assuré que le serveur est démarré (cf. chapitre précédent).
 +
  { [SinOsc.ar(440, 0, 0.2), SinOsc.ar(442, 0, 0.2)] }.play;
 +
 +
Quand vous en avez marre, appuyez sur Cmd - . (maintenez la touche Commande enfoncée et appuyez sur la touche point ou arrêt complet: Cmd + Maj + . ) pour arrêter le son. Cela arrêtera toujours tous les sons dans SC. Vous l'utiliserez beaucoup, alors mémorisez-la bien.
 +
 +
 +
Pas très inspirant ? Ne vous inquiétez pas, nous ne faisons que commencer, et ceci n'est qu'un exemple simple pour démontrer des fonctions et du son.
 +
Une fonction est juste un fragment de code réutilisable. Vous définissez une fonction en entourant le code entre 'accolades': {}. Voici un exemple :
 +
  f = { "Function evaluated".postln; };
 +
 +
Ce qui se trouve dans les accolades est ce qui sera exécuté chaque fois que vous réutiliserez ou évaluerez la fonction. Notez que ceci s’écrit comme une équation, c’est-à-dire f = {...}. Ce n'est pas une équation au sens mathématique, c'est ce que l'on appelle une assignation. En gros, cela me permet de nommer la fonction que j'ai créée en la stockant dans une variable appelée f. Une variable est simplement un nom représentant un emplacement dans lequel nous pouvons stocker des éléments, tels qu'une fonction, un nombre, une liste, etc. Exécutez les lignes suivantes une à la fois et regardez la fenêtre de publication :
 +
  f = { "Function evaluated".postln; };
 +
  f;
 +
 +
Les deux fois, il devrait indiquer «a Function». Maintenant, chaque fois que nous voulons faire référence à notre fonction, nous pouvons simplement utiliser la lettre f. C'est ce qui la rend réutilisable ! Sinon, nous aurions besoin de taper la fonction à chaque fois.
 +
Alors, comment pouvons-nous le réutiliser ? Exécutez les lignes suivantes une à la fois et regardez la fenêtre de publication :
 +
  f = { "Function evaluated".postln; };
 +
  f.value;
 +
  f.value;
 +
  f.value;
 +
 +
Notre fonction est un objet (c’est-à-dire une chose qui fait ou représente quelque chose), que nous avons défini et stocké dans la variable f. Le morceau de code 'value' ​​dit qu’il évalue maintenant cette fonction. Ceci est un exemple d'envoi d'un message à un objet. Cela suit la syntaxe someObject.someMessage. Le point doit aller entre.
 +
 +
Maintenant, cette partie suivante est un peu délicate. Dans un objet donné, chaque message appelle (appelle = exécute) une méthode particulière. Différents types d'objets peuvent avoir des méthodes portant le même nom et donc répondre au même message de différentes manières. Whoah, vous l’avez ? Relisez-le lentement, car c'est très important:
 +
Différents types d'objets peuvent avoir des méthodes portant le même nom et donc répondre au même message de différentes manières.
 +
 +
=Détection sonore d'un micro par le Raspberry=
 +
==Introduction==
 +
 +
Il s'agit de l'extension du projet d’orchestration "Chantier en chantier", mené en cours d'AP et qui cherche à établir une relation entre le chantier de Kanal et un chantier fictif mis en place à l'Erg.
 +
 +
Le but du projet en programmation est d’établir une relation par le code entre le chantier fictif et le réel. Les informations sur les sons collectés permettent une réinterprétation de ces sons dans une installation-orchestre.
 +
 +
En choisissant de l’harmoniser, le chantier ne se subit plus, il s’écoute.
 +
 +
==Programmation==
 +
 +
Le code utilisé :
 +
 +
#!/usr/bin/python
 +
## This is an example of a simple sound capture script.
 +
##
 +
## The script opens an ALSA pcm for sound capture. Set
 +
## various attributes of the capture, and reads in a loop,
 +
## Then prints the volume.
 +
##
 +
## To test it out, run it and shout at your microphone:
 +
import alsaaudio, time, audioop
 +
# Open the device in nonblocking capture mode. The last argument could
 +
# just as well have been zero for blocking mode. Then we could have
 +
# left out the sleep call in the bottom of the loop
 +
inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,alsaaudio.PCM_NONBLOCK)
 +
# Set attributes: Mono, 8000 Hz, 16 bit little endian samples
 +
inp.setchannels(1)
 +
inp.setrate(8000)
 +
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
 +
# The period size controls the internal number of frames per period.
 +
# The significance of this parameter is documented in the ALSA api.
 +
# For our purposes, it is suficcient to know that reads from the device
 +
# will return this many frames. Each frame being 2 bytes long.
 +
# This means that the reads below will return either 320 bytes of data
 +
# or 0 bytes of data. The latter is possible because we are in nonblocking
 +
# mode.
 +
inp.setperiodsize(160)
 +
while True:
 +
    # Read data from device
 +
    l,data = inp.read()
 +
    if l:
 +
        # Return the maximum of the absolute value of all samples in a fragment.
 +
        print audioop.max(data, 2)
 +
    time.sleep(.001)
 +
 +
 +
Voir quel est le périphérique audio par défaut :
 +
pi@justine:~ $  alsamixer
 +
 +
 +
Liste des périphériques connectés au RaspberryPi (avec un « L » bas-de-casse) :
 +
pi@justine:~ $ aplay -l 
 +
 +
 +
Pour modifier le port audio :
 +
pi@justine:~ $ sudo nano /usr/share/alsa/alsa.conf
 +
 +
 +
Chercher la section où sera écrit :
 +
defaults.ctl.card 0
 +
defauts.pcm.card 0 
 +
Et la modifier en :
 +
defaults.ctl.card 1
 +
defauts.pcm.card 1
 +
 +
== Configurer un micro-usb comme source audio par défaut ==
 +
 +
Créer le fichier '''.asoundrc'''
 +
pi@justine:~ $ sudo nano .asoundrc
 +
 +
Dans ce fichier, saisir le code :
 +
pcm.!default{
 +
type hw
 +
card 1
 +
}
 +
ctl.!default{
 +
type hw
 +
card 1
 +
}
 +
 +
=Enregistrer les données récoltées par le micro dans un fichier texte=
 +
 +
Trouver l’endroit où s’affiche la donnée pour y insérer le code
 +
 +
nomFichier : fichierPtr (= "fichier Pointeur")
 +
 +
print audioop.max(data, 2)
 +
fichierPtr = open(« Output.txt », « w »)
 +
fichierPtr.write(audioop.max(data,2))
 +
fichierPtr.close()
 +
 +
 +
Que signifie "audioop.max(data, 2)" ?
 +
"audioop.max(fragment, width)
 +
Return the maximum of the absolute value of all samples in a fragment"
 +
 +
 +
*Ouvrir nouvelle fenêtre du terminal avec la commande :
 +
Ctl + Alt + t
 +
 +
*Surveiller Output.txt en même temps que s’exécute "testaudio.py" en tapant :
 +
tail -f Documents/test/Output.txt
 +
 +
Passage d’une fenêtre à l’autre :
 +
Alt + Tab
 +
 +
==Brancher un nouveau périphérique d’enregistrement==
 +
 +
Vérifier que le RasPi reconnaisse le micro :
 +
lsusb
 +
 +
Si le micro n’est pas connecté :
 +
[pofilo@RPI3:~]$ lsusb
 +
Bus 001 Device 005: ID 0424:7800 Standard Microsystems Corp.
 +
Bus 001 Device 003: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
 +
Bus 001 Device 002: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
 +
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
 +
 +
Si le micro est connecté :
 +
[pofilo@RPI3:~]$ lsusb
 +
Bus 001 Device 013: ID 0556:0002 Asahi Kasei Microsystems Co., Ltd
 +
Bus 001 Device 005: ID 0424:7800 Standard Microsystems Corp.
 +
Bus 001 Device 003: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
 +
Bus 001 Device 002: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
 +
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub
 +
 +
==Étapes à suivre pour que observer les valeurs de la fréquence sonore captées par le micro==
 +
*Lancer programme "testaudio.py"
 +
pi@justine:~ $ cd Documents/test/
 +
pi@justine:~/Documents/test $ python testaudio.py
 +
 +
*Ouvrir nouvelle fenêtre 
 +
Ctrl + Alt + t
 +
 +
*Surveiller le fichier "Output.txt"
 +
pi@justine:~/Documents/test $ tail -f Output.txt
 +
 +
—————————————
 +
 +
=À suivre...=
 +
 +
==Comment le micro va capter le son des différentes machines du chantier de Kanal ?==
 +
 +
Plusieurs solutions...
 +
*Fixer un seul micro à un endroit et capter le son selon des "paliers" sonores établis (de x à y dB lancer machine a du chantier fictif, de y à z dB lancer machine b du chantier fictif, etc)
 +
*Un RasPi et micro par machine : si l'intensité sonore est supérieure à x dB, alors la machine est activée à Kanal donc on lance la machine dans le chantier fictif
 +
...
 +
 +
Faire des test de sons de machines avec un micro et Raspberry (min dB et max dB)
 +
 +
Connecter les deux RaspberryPi (celui de Kanal et celui du chantier fictif) via un serveur en ligne
 +
 +
L'autre programme à créer avec le Raspberry Pi :
 +
#Lire les données de Output.txt
 +
#Si la valeur de Output.txt est comprise entre x et y ou est supérieure/ inférieure à x alors...
 +
#Lancement ou non du programme « lancer la machine a » sur le chantier fictif

Version actuelle datée du 13 mai 2019 à 09:00

Live coding

le live coding est la pratique d’écriture de code en direct, devant une audience, principalement dans un contexte de création de musique ou de visuel.

Session du 01/10/2018

Justine, Danaé

Exemples de logiciels de live coding

Un wiki sur le live coding


Références : Collectifs, Artistes sonores et visuels

Session du 08/10/2018

Danaé, Justine

Projet : Faire du live coding audio d'après des sons enregistrés dans le bâtiment même et lus en direct.

Livcod.jpg

Dans un premier temps, nous allons d'abord nous concentrer sur la partie de droite, la captation et l'enregistrement de sons. Cette partie du programme peut être écrite en C et ne concernera que les RasberryPi.

1. Trouver une bibliothèque C permettant de se connecter à un micro et d'exporter de l'audio FmodEx

Session du 05/11/2018

Justine, Danaé

Microhp.gif

L'objectif est d'envoyer à l'ordinateur une information numérique semblable à la grandeur physique que le microphone doit acquérir (ici enregistrer un son). 


class ofApp : public ofBaseApp {
 // ... other things ...
 void audioOut( float * output, int bufferSize, int nChannels );
 double phase;
};

void ofApp::setup() {
 phase = 0;
 ofSoundStreamSetup(2, 0); // 2 output channels (stereo), 0 input channels
}

void ofApp::audioOut( float * output, int bufferSize, int nChannels ) {
 for(int i = 0; i < bufferSize * nChannels; i += 2) {
   float sample = sin(phase); // generating a sine wave sample
   output[i] = sample; // writing to the left channel
   output[i+1] = sample; // writing to the right channel
   phase += 0.05;
 }
}

Session du 26/11/2018

Justine, Danaé

Enregistre un fichier texte dans le dossier "bin" du projet. 

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
   ofstream myfile("example.txt",ios::app);
   cout<<myfile.tellp()<<endl;
   myfile.seekp(24, ios::end);
   cout<<myfile.tellp()<<endl;
   myfile<<"Premier essai";
}

RegisterTxt.png



Par contre si la phrase est effacée, remplacé et le code à nouveau exécuté, le fichier "example.txt" n'est pas remplacé, mais les phrases s'écrivent à la suite.

EcrisSuite.png

Session du 10/12/2018

Justine

01/ Hello World, I'm SuperCollider

Lors de l’apprentissage d’un nouveau langage de programmation, la coutume veut que l’on commence par un programme simple appelé «Hello World». Cela affiche le texte 'Hello World!' partout où le programme devra afficher du texte. En SC, cet endroit est appelé la fenêtre de publication ('post window' en anglais). La fenêtre de publication est démarrée lorsque vous avez lancé SC pour la première fois. Un tas de choses y ont été affichées, et ressemblent à ceci : 

   init_OSC
   compiling class library..
   NumPrimitives = 587
   compiling dir: '/Applications/SC3/SCClassLibrary'
   pass 1 done
   Method Table Size 3764776 bytes
   Number of Method Selectors 3184
   Number of Classes 1814
   Number of Symbols 7595
   Byte Code Size 180973
   compiled 296 files in 1.34 seconds
   compile done
   RESULT = 256
   Class tree inited in 0.14 seconds

Ne vous inquiétez pas trop de ce que tout cela signifie pour le moment, gardez simplement à l’esprit que c’est là où SC vous enverra des informations. C'est également là que nous aurons le résultat de notre programme 'Hello World', que vous pouvez voir ci-dessous : 

  "Hello World".postln;

Pour l'exécuter, cliquez simplement pour placer le curseur quelque part sur la même ligne que le code puis appuyez sur Maj-Entrée. Essayez maintenant.

Si tout se passe bien, vous devriez voir ceci dans la fenêtre de publication : 

  Hello World!
  -> Hello World!

Sinon, vous pouvez également sélectionner le code que vous souhaitez exécuter, puis appuyer sur Ctrl-Entrée.

Examinons maintenant le code de plus près. Le premier fragment, "Hello World!", est une sorte d'objet, appelé une chaîne ('string' en anglais). Un objet est fondamentalement un moyen de représenter quelque chose sur l'ordinateur, par exemple un morceau de texte ou un oscillateur, qui vous permet de le contrôler et de lui envoyer des messages. Plus d’informations à ce sujet plus tard, mais pour l’instant, il suffit de comprendre qu’une chaîne est un moyen de représenter un peu de texte. Le second fragment, .postln;, dit « affiche-moi (ou une description explicite de moi) dans la fenêtre de publication ».

Rappelez-vous postln est votre ami. Vous pouvez l'appliquer à presque tout dans SC et obtenir quelque chose de significatif en retour. Cela peut être très pratique lorsque vous recherchez des bugs dans votre code.

Pourquoi l’a-il imprimé deux fois ? Eh bien, lorsque vous exécutez du code dans SC, il affiche toujours le résultat du dernier fragment de code (la dernière instruction). Donc, il imprime en premier lieu parce que nous lui avons explicitement dit d'imprimer, puis il affiche le résultat de cette opération, qui se trouve être la même chose dans ce cas-ci. Donc ici, nous n’avions pas vraiment besoin du fragment postln. Mais dans l'exemple suivant, cela nous sera utile. Copiez les deux lignes de texte suivantes, puis exécutez-les, en appuyant sur Maj-Entrée. 

  "Hello there, I'm SuperCollider!".postln;
  "Hello World!".postln;



La première ligne, 'Hello there, I'm SuperCollider!' n'aurait pas été imprimé si nous n'avions pas déclaré le postln. En général, lorsque vous êtes censé exécuter plusieurs lignes de code en même temps, elles seront entourées de parenthèses, comme dans l'exemple ci-dessous. Vous pouvez placer votre curseur n'importe où dans cette région (ou sur la ligne des parenthèses sur le Mac), puis double-cliquez et appuyez sur Ctrl-Entrée ou Maj-Entrée - ceci sélectionne toute la région et l'exécute. Essayez-le sur l'exemple ci-dessous. 

  (
  "Hello there, I'm SuperCollider!".postln;
  "Hello World!".postln;
  )

Fenêtre de publication : 

  Hello there, I'm SuperCollider!
  Hello World!
  -> Hello World!

Un double-clic à l’intérieur d’une paire de parenthèses englobantes peut ne pas sélectionner toute la zone dans certains systèmes, notamment sur les Mac modernes. Pour certains, cela ne sélectionne que le mot double-cliqué. Ainsi, il peut être utile de prendre l'habitude de toujours vérifier que vous avez sélectionné tout le code souhaité, quelle que soit la technique de sélection, avant d'appuyer sur Ctrl-Entrée ou sur Maj-Entrée. Faites des essais pour savoir comment votre système se comporte. Lorsque le code n'est pas entouré de parenthèses, il est généralement destiné à être exécuté ligne par ligne. Vous pouvez placer votre curseur n'importe où dans une ligne de code et appuyer sur les touches Ctrl-Entrée ou Maj-Entrée pour sélectionner la ligne entière et l'exécuter. Notez que chacune des lignes du bloc de code se termine par un point-virgule. Ceci est très important lorsque vous exécutez plusieurs lignes de code. De plus, la fenêtre de publication devient parfois pleine de choses difficiles à lire. Vous pouvez l’effacer à tout moment en appuyant sur Cmd-shift-p (maintenez la touche Commande et la touche Maj enfoncées, puis appuyez sur p).

Live coding SON

Danaé

Télécharger le programme SonicPi , destiné au live coding de son uniquement; très pratique car il comprend un tutoriel clair et complet, ce qui permet de tester les choses au fur-et-à-mesure qu'on les découvre.

Un exemple d'utilisation ici Et encore ici, par le créateur même de sonic pi Sam Aaron

Un manuel d'utilisation de synthétiseurs, dont certains chapitres aident à comprendre quels sont les paramètres d'un son, et du coup comment on peut les modifier et les créer par la suite, avec sonic Pi par exemple. Le manuel est assez technique alors nous allons reprendre les principales caractéristiques d'une onde sonore ci-dessous :

Onde.png

  • A :Key On : Pression de la touche
  • B. Key Off : Relâchement de la touche
  • C : temps
  • D : Hauteur de ton
  • E : Hold time
  • F : Attack time
  • G : Decay 1 time
  • H : Decay 2 time
  • I : Release time
  • J : hold level
  • K : attack level
  • L : decay 1 level
  • M : decay 2 level = sustain level
  • N : release level

Description.png

Dans Sonic Pi, tous ces paramètres sont visibles dans la partie "Echantillons", il y a également une description de chacun d'eux, etc.

Session du 18/12/2018

Justine

02/ Le monde selon SuperCollider

SuperCollider est en réalité trois programmes:

  • l'éditeur de texte (ou IDE),
  • le langage (sclang ou application 'client'),
  • et le serveur, qui effectue la synthèse et le calcul de l'audio.

La partie sclang est un langage de programmation sophistiqué avec d’agréables fonctionnalités d'interface graphique; et la partie serveur est une application de ligne de commande UNIX simple, légère et efficace (ce qui signifie qu’elle s’exécute sans représentation graphique). Ils communiquent via un protocole appelé Open Sound Control (OSC), via UDP ou TCP, protocoles réseau également utilisés sur Internet. Ne pensez donc pas que les deux applications doivent fonctionner sur des ordinateurs différents (elles peuvent le faire, ce qui peut présenter des avantages évidents en termes de performances), ou qu'elles doivent être connectées à Internet (bien qu'il soit possible d'avoir des clients et des serveurs dans différentes parties du monde communiquant !!). La plupart du temps, ils fonctionneront sur la même machine.

Le langage de l’application dispose de nombreux objets puissants qui représentent des éléments sur le serveur et vous permettent de les contrôler facilement. Comprendre comment cela fonctionne est crucial pour maîtriser SC, nous en parlerons donc de manière plus approfondie.

Mais d'abord amusons-nous un peu et faisons du son ...

[Exercice suggéré]

Ouvrez une nouvelle fenêtre en appuyant sur Ctrl-N (Cmd-N sur Mac) ou choisissez "New" dans le menu "File". Enregistrez le document en lui donnant un nom tel que "premierCodeSC.scd". Notez que vous devez toujours utiliser l'extension '.scd' pour les fichiers contenant du code SC. 

  x = {SinOsc.ar(MouseX.kr(100,500))}.play
  x.free //pour arrêter le son

Copiez quelques exemples de code ci-dessus, ou celui ci-dessous, et collez-les dans le nouveau document (les raccourcis standard Ctrl-C et Ctrl-V (Cmd-C et Cmd-V sur Mac) fonctionnent pour copier-coller ou utilisez le menu Edit). Essayez de modifier le texte entre les guillemets pour imprimer différentes choses dans la fenêtre de publication.

SC vous permettra de modifier les fichiers d’aide et la documentation. C’est donc une bonne idée de copier du texte avant de le modifier afin d’éviter de sauvegarder accidentellement des fichiers modifiés !

03. Lancez les moteurs !

Avant de pouvoir émettre un son, nous devons démarrer ou «initialiser» (boot) une application serveur. Le moyen le plus simple consiste à utiliser le raccourci Ctrl-B (Cmd-B sur Mac). Il existe également un menu « Server » dans lequel on peut utiliser "Boot Server » pour démarrer les paramètres audio.


Boot0.png

Boot1.png

Notez que la police blanche sur la vue noire au bas de la fenêtre a été changée en vert. Cela indique que le serveur est en cours d'exécution. La vue fournit également des informations sur l'utilisation du processeur et d'autres éléments qui ne sont probablement pas encore clairs. Plus à ce sujet bientôt.


Jetez également un coup d'œil à la fenêtre de publication, où SC vous a donné des informations, et vous indique qu'il a bien démarré :

PostbootOK.png


Si, pour une raison quelconque, le démarrage échouait, des informations l’indiqueraient. Par défaut, vous pouvez faire référence au serveur localhost dans votre code en utilisant la lettre s. Vous pouvez donc envoyer des messages pour le démarrer et l’arrêter ainsi: 

  s.quit;
  s.boot;

Essayez ceci et laissez le serveur en marche. De nombreux exemples dans la documentation incluent s.boot au début, mais en général vous devez vous assurer que le serveur est en marche avant d'utiliser des exemples qui génèrent de l'audio, ou accéder au serveur. En général, les exemples de ce tutoriel supposent que le serveur est en cours d'exécution.

Vous pouvez également faire référence au serveur localhost avec le texte Server.local, par exemple: 

  Server.local.boot;

04. Fonctions et autres fonctionnalités

Le moyen le plus simple d'obtenir du son depuis SC est d'utiliser une fonction. Vous trouverez ci-dessous un exemple simple. Exécutez-le après vous être assuré que le serveur est démarré (cf. chapitre précédent). 

  { [SinOsc.ar(440, 0, 0.2), SinOsc.ar(442, 0, 0.2)] }.play;

Quand vous en avez marre, appuyez sur Cmd - . (maintenez la touche Commande enfoncée et appuyez sur la touche point ou arrêt complet: Cmd + Maj + . ) pour arrêter le son. Cela arrêtera toujours tous les sons dans SC. Vous l'utiliserez beaucoup, alors mémorisez-la bien.


Pas très inspirant ? Ne vous inquiétez pas, nous ne faisons que commencer, et ceci n'est qu'un exemple simple pour démontrer des fonctions et du son. Une fonction est juste un fragment de code réutilisable. Vous définissez une fonction en entourant le code entre 'accolades': {}. Voici un exemple : 

  f = { "Function evaluated".postln; };

Ce qui se trouve dans les accolades est ce qui sera exécuté chaque fois que vous réutiliserez ou évaluerez la fonction. Notez que ceci s’écrit comme une équation, c’est-à-dire f = {...}. Ce n'est pas une équation au sens mathématique, c'est ce que l'on appelle une assignation. En gros, cela me permet de nommer la fonction que j'ai créée en la stockant dans une variable appelée f. Une variable est simplement un nom représentant un emplacement dans lequel nous pouvons stocker des éléments, tels qu'une fonction, un nombre, une liste, etc. Exécutez les lignes suivantes une à la fois et regardez la fenêtre de publication : 

  f = { "Function evaluated".postln; };
  f;

Les deux fois, il devrait indiquer «a Function». Maintenant, chaque fois que nous voulons faire référence à notre fonction, nous pouvons simplement utiliser la lettre f. C'est ce qui la rend réutilisable ! Sinon, nous aurions besoin de taper la fonction à chaque fois. Alors, comment pouvons-nous le réutiliser ? Exécutez les lignes suivantes une à la fois et regardez la fenêtre de publication : 

  f = { "Function evaluated".postln; };
  f.value;
  f.value;
  f.value;

Notre fonction est un objet (c’est-à-dire une chose qui fait ou représente quelque chose), que nous avons défini et stocké dans la variable f. Le morceau de code 'value' ​​dit qu’il évalue maintenant cette fonction. Ceci est un exemple d'envoi d'un message à un objet. Cela suit la syntaxe someObject.someMessage. Le point doit aller entre.

Maintenant, cette partie suivante est un peu délicate. Dans un objet donné, chaque message appelle (appelle = exécute) une méthode particulière. Différents types d'objets peuvent avoir des méthodes portant le même nom et donc répondre au même message de différentes manières. Whoah, vous l’avez ? Relisez-le lentement, car c'est très important: Différents types d'objets peuvent avoir des méthodes portant le même nom et donc répondre au même message de différentes manières.

Détection sonore d'un micro par le Raspberry

Introduction

Il s'agit de l'extension du projet d’orchestration "Chantier en chantier", mené en cours d'AP et qui cherche à établir une relation entre le chantier de Kanal et un chantier fictif mis en place à l'Erg.

Le but du projet en programmation est d’établir une relation par le code entre le chantier fictif et le réel. Les informations sur les sons collectés permettent une réinterprétation de ces sons dans une installation-orchestre.

En choisissant de l’harmoniser, le chantier ne se subit plus, il s’écoute.

Programmation

Le code utilisé : 

#!/usr/bin/python
## This is an example of a simple sound capture script.
##
## The script opens an ALSA pcm for sound capture. Set
## various attributes of the capture, and reads in a loop,
## Then prints the volume.
##
## To test it out, run it and shout at your microphone:
import alsaaudio, time, audioop
# Open the device in nonblocking capture mode. The last argument could
# just as well have been zero for blocking mode. Then we could have
# left out the sleep call in the bottom of the loop
inp = alsaaudio.PCM(alsaaudio.PCM_CAPTURE,alsaaudio.PCM_NONBLOCK)
# Set attributes: Mono, 8000 Hz, 16 bit little endian samples
inp.setchannels(1)
inp.setrate(8000)
inp.setformat(alsaaudio.PCM_FORMAT_S16_LE)
# The period size controls the internal number of frames per period.
# The significance of this parameter is documented in the ALSA api.
# For our purposes, it is suficcient to know that reads from the device
# will return this many frames. Each frame being 2 bytes long.
# This means that the reads below will return either 320 bytes of data
# or 0 bytes of data. The latter is possible because we are in nonblocking
# mode.
inp.setperiodsize(160)
while True:
   # Read data from device
   l,data = inp.read()
   if l:
       # Return the maximum of the absolute value of all samples in a fragment.
       print audioop.max(data, 2)
   time.sleep(.001)


Voir quel est le périphérique audio par défaut : 

pi@justine:~ $  alsamixer


Liste des périphériques connectés au RaspberryPi (avec un « L » bas-de-casse) : 

pi@justine:~ $ aplay -l


Pour modifier le port audio : 

pi@justine:~ $ sudo nano /usr/share/alsa/alsa.conf


Chercher la section où sera écrit : 

defaults.ctl.card 0
defauts.pcm.card 0

Et la modifier en : 

defaults.ctl.card 1
defauts.pcm.card 1

Configurer un micro-usb comme source audio par défaut

Créer le fichier .asoundrc 

pi@justine:~ $ sudo nano .asoundrc

Dans ce fichier, saisir le code : 

pcm.!default{
type hw
card 1
}
ctl.!default{
type hw
card 1
}

Enregistrer les données récoltées par le micro dans un fichier texte

Trouver l’endroit où s’affiche la donnée pour y insérer le code

nomFichier : fichierPtr (= "fichier Pointeur") 

print audioop.max(data, 2)

fichierPtr = open(« Output.txt », « w ») fichierPtr.write(audioop.max(data,2)) fichierPtr.close()


Que signifie "audioop.max(data, 2)" ? 

"audioop.max(fragment, width)
Return the maximum of the absolute value of all samples in a fragment"


  • Ouvrir nouvelle fenêtre du terminal avec la commande :
Ctl + Alt + t
  • Surveiller Output.txt en même temps que s’exécute "testaudio.py" en tapant :
tail -f Documents/test/Output.txt

Passage d’une fenêtre à l’autre : 

Alt + Tab

Brancher un nouveau périphérique d’enregistrement

Vérifier que le RasPi reconnaisse le micro : 

lsusb

Si le micro n’est pas connecté : 

[pofilo@RPI3:~]$ lsusb
Bus 001 Device 005: ID 0424:7800 Standard Microsystems Corp. 
Bus 001 Device 003: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
Bus 001 Device 002: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Si le micro est connecté : 

[pofilo@RPI3:~]$ lsusb
Bus 001 Device 013: ID 0556:0002 Asahi Kasei Microsystems Co., Ltd 
Bus 001 Device 005: ID 0424:7800 Standard Microsystems Corp. 
Bus 001 Device 003: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
Bus 001 Device 002: ID 0424:2514 Standard Microsystems Corp. USB 2.0 Hub
Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub

Étapes à suivre pour que observer les valeurs de la fréquence sonore captées par le micro

  • Lancer programme "testaudio.py"
pi@justine:~ $ cd Documents/test/
pi@justine:~/Documents/test $ python testaudio.py
  • Ouvrir nouvelle fenêtre
Ctrl + Alt + t
  • Surveiller le fichier "Output.txt"
pi@justine:~/Documents/test $ tail -f Output.txt

—————————————

À suivre...

Comment le micro va capter le son des différentes machines du chantier de Kanal ?

Plusieurs solutions...

  • Fixer un seul micro à un endroit et capter le son selon des "paliers" sonores établis (de x à y dB lancer machine a du chantier fictif, de y à z dB lancer machine b du chantier fictif, etc)
  • Un RasPi et micro par machine : si l'intensité sonore est supérieure à x dB, alors la machine est activée à Kanal donc on lance la machine dans le chantier fictif

...

Faire des test de sons de machines avec un micro et Raspberry (min dB et max dB)

Connecter les deux RaspberryPi (celui de Kanal et celui du chantier fictif) via un serveur en ligne

L'autre programme à créer avec le Raspberry Pi :

  1. Lire les données de Output.txt
  2. Si la valeur de Output.txt est comprise entre x et y ou est supérieure/ inférieure à x alors...
  3. Lancement ou non du programme « lancer la machine a » sur le chantier fictif
Récupérée de « https://curlybraces.be/wiki/index.php?title=ERG::livecoding&oldid=3295 »