Archivi categoria: ChucK

ChucK 101 – Lezione 3: Questione di tempo

È passato un po’ di tempo dalla seconda lezione e, ormai, dovreste aver acquisito una certa familiarità con le variabili e i tipi di dati in ChucK. Negli esempi che abbiamo fatto visto fino a oggi abbiamo usato una parola chiave che non abbiamo mai approfondito: now.

In ChucK, così come in tutti i linguaggi di programmazione, esistono delle parole chiave che sono “riservate” perché permettono al linguaggio stesso di funzionare e, quindi, non possono essere usate per attribuire a variabili create dall’utente quel nome specifico. Ad esempio, non possiamo creare una variabile di nome now perché per il compilatore quella parola ha già un significato ben preciso. La regola generale dice che tutte le parole che dentro miniAudicle vengono colorate, sono parole chiave riservate.

La variabile di durata “dur”

Possiamo utilizzare la parola chiave dur per determinare delle variabili di durata. Riprendiamo l’ultimo esempio fatto nel precedente post (quello con le variabili di tipo float) e aggiungiamo delle variabili di durata.

/*
 * Chuck 101 - Lezione 3
 * Questione di tempo
 */
 SinOsc sine => dac;
// Middle C (in Hz)
 261.626 => float myFrequency;
// Volume as a variable
 0.6 => float myVolumeOn;
 0 => int myVolumeOff;
// Variabili di durata
 0.50::second => dur onDuration;
 0.75::second => dur offDuration;
// Suoniamo una nota
 myFrequency => sine.freq;
 myVolumeOn => sine.gain;
 onDuration => now;
myVolumeOff => sine.gain;
 offDuration => now;
// Suoniamo un'altra nota al doppio della frequenza
 2 *=> myFrequency;
myFrequency => sine.freq;
 myVolumeOn => sine.gain;
 onDuration => now;
myVolumeOff => sine.gain;
 offDuration => now;

Analizziamo il codice che abbiamo appena scritto: all’inizio del programma abbiamo deciso di utilizzare un’oscillatore con onda sinusoidale a cui abbiamo assegnato una frequenza pari a 261.626 Hz (Do centrale); abbiamo due variabili di volume: la prima a 0.6 (nota ON) e la seconda a 0 (nota OFF). Nel primo caso abbiamo utilizzato una variabile float in quanto il valore è decimale, nel secondo caso una variabile di tipo integer. Abbiamo dichiarato due variabili di durata utilizzando la parola chiave dur.

Nelle blocco di codice tra le righe 18 e 24, facciamo suonare al nostro oscillatore una nota per 0.5 secondi per poi fare una pausa (impostando il gain a 0) di 0.75 secondi. Nel blocco dalla riga 26 alla fine del progetto, ripetiamo la stessa operazione raddoppiando, però, la frequenza riprodotta.

Altre variabili di tempo

Oltre a now durin ChucK sono previste altre parole chiave di tempo:

samp che corrisponde a 1 sample digitale e dipende dalla frequenza di campionamento (normalmente 1 sample equivale a 1/44100 di secondo), ms ovvero millisecondi, second per i secondi, minute per i minuti, hour per le ore, day per i giorni, week per le settimane. Mancano le variabili “mesi” e “anni” perché, come ben sappiamo, posso avere durate diverse (mesi di 28, 30 o 31 giorni e anni di 365 o 366 giorni).

Questione di tempo

Nel post introduttivo avevo accennato all’importanza del tempo in ChucK. Non dobbiamo dimenticare che senza lo scorrere del tempo il suono e, di conseguenza, la musica non potrebbero esistere. Grazie alla lezione di oggi, abbiamo scoperto che in ChucK possiamo cominciare a manipolare il tempo a nostro piacimento.

Cose importanti da ricordare:

  • le variabili di tempo durata sono native in ChucK (come le variabili integerfloat).
  • la variabile now rappresenta sempre il tempo corrente in ChucK (riparte ogni volta da 0 quando avviamo la Virtual Machine).
  • l’unico modo per far scorrere il tempo in ChucK è manipolare la variabile now.

Dal momento che le variabili di tempo e durata sono native, possiamo ovviamente seguire operazioni matematiche tra di esse per creare nuove variabili di tempo.

2::second + 1::minute => dur newDur;

Nella musica “suonata” il tempo viene contatto in BPM (Beats Per Minute) e non in secondi. Come ovviare a questo problema? Creando delle variabili come nell’esempio seguente:

// Impostiamo i quarti (seminima) a 0.8 secondi (75BPM)
 0.8::second => dur quarter;
// Impostiamo, di conseguenza, il valore della semibreve o intero
 4::quarter => dur whole;
// Impostiamo il valore della minima (1/2)
 whole/2 => dur half;
// Impostiamo il valore della croma (1/8)
 quarter/2 => dur eighth;

Random Music

Vi lascio con un ultimo programma, molto semplice, che genera musica in modo assolutamente casuale. In questa porzione di codice ci sono cose che ancora non abbiamo visto ma i commenti inseriti credo lo rendano piuttosto chiaro:

/* Random Music */
SinOsc sine => dac;
// Loop infinito
 while (true)
 {
 // Frequenza casuale tra 100 e 1000
 Math.random2(100,1000) => sine.freq;
// Durata casuale tra 30 e 1000 ms
 Math.random2f(30,1000) :: ms => now;
 }

Chuck 101 – Lezione 2: Tipi di dati e variabili

Con la prima lezione abbiamo cominciato ad avventurarci nel fantastico mondo di ChucK; ora è arrivato il momento di definire un paio di concetti fondamentali per sviluppare le nostre future applicazioni musicali: tipologie di dati e variabili.

Tipi di dati

La maggior parte dei dati che ci troveremo a gestire all’interno di ChucK sono numeri. Quando si programma si incontrano principalmente due categorie di numeri: integerfloating points. Nel primo gruppo rientrano tutti i numeri senza decimali, nel secondo quelli che invece li hanno.

1 – 45 – 3945 – 20395 sono tutti numeri di tipo integer.

1.2 – 2.3495 – 294056.1 – 394.12 sono, invece, dei float (abbreviazione di floating points).

Esempio 1: Integer

In questo programma in ChucK, opportunamente commentato, vediamo come creare una variabile chiamata «a» a cui assegnamo un valore integer pari a 4. Infine, stampiamo a schermo la nostra variabile:

/*
* Chuck 101 - Lezione 2
* Tipi di dati e variabili
*/
// Esempio Integer
// Definiamo una variabile 'a' come integer;
int a;
// Assegnamo alla nostra variabile un valore numerico
4 => a;
// Scriviamo il valore di a
<<< a >>>;

Se avete fretta c’è un metodo più veloce per assegnare un valore direttamente a una variabile; possiamo sostituire la definizione della variabile e l’assegnazione nel precedente programma con il seguente codice:

/*
* Chuck 101 - Lezione 2
* Tipi di dati e variabili
*/
// Esempio Integer
// Definiamo una variabile 'a' come integer;
int a;
// Assegnamo alla nostra variabile un valore numerico
4 => int a;
// Scriviamo il valore di a
<<< a >>>;

Operazioni matematiche

Ora che abbiamo imparato ad assegnare numeri a delle variabili, possiamo sbizzarrirci con le operazioni matematiche;

Provate a scrivere nel vostro programma:

// Definiamo una variabile 'a' come integer;
4 => int a;
// Moltiplichiamo per 4 la nostra variabile
5*a => a;
// Scriviamo il valore di a
<<< a >>>;

Se tutto è stato scritto correttamente,  nella virtual machine dovreste leggere: 20 : (int)

Anche in questo caso possiamo ricorrere alla seguente scorciatoia per velocizzare la programmazione:

// Definiamo una variabile 'a' come integer;
4 => int a;
// Moltiplichiamo per 4 la nostra variabile
5*=> a;
// Scriviamo il valore di a
<<< a >>>;

Esempio 2: Floating Points

Utilizziamo ora una variabile ti tipo floating points (quindi con dei numeri decimali) all’interno di un programma “musicale”.

/*
* Chuck 101 - Lezione 2
* Tipi di dati e variabili
*/
SinOsc sine => dac;

// Middle C (in Hz)
261.626 => float myFrequency;
// Volume as a variable
0.6 => float myVolume;

// Imposto la frequenza
myFrequency => sine.freq;
// Imposto il volume
myVolume => sine.gain;

// Imposto la durata a 1 secondo.
1::second => now;

Questo piccolo programma riprende in parte quanto fatto la prima lezione ma, anziché assegnare dei valori direttamente alla frequenza e al volume, abbiamo assegnato i valori numeri a delle variabili; così facendo, come vedremo nelle prossime lezioni, potremo modificare i valori con l’avanzare del tempo nel programma.

Per chi se lo stesse chiedendo, il valore 261.626 non è casuale ma è quello riportato in questa tabella e indica, come riportato nel commento, l’esatta frequenza del do centrale nel pianoforte.

Altri tipi di dati

Abbiamo visto variabili di tipo numerico che, come già detto in precedenza, saranno quelle che useremo maggiormente. In ChucK, però, possiamo definire anche altri tipi di variabili: char (un singolo carattere, es: “a”, “b”, “z”, …), string (una stringa di caratteri, es: “hello”, “ciao”, “cartella/fileaudio.wav”), dur (per definire la durata, es: 1::second) e, infine, time (definisce la durata in sample).

Compiti a casa

Nella prossima lezione, analizzeremo nel dettaglio le variabili temporali e la gestione del tempo in ChucK. Nel frattempo, con le nozioni apprese oggi, provate a sperimentare con suoni, variabili e funzioni matematiche per modificare la frequenza assegnata al vostro oscillatore.

ChucK 101 – Lezione 1: Hello Sine!

Benvenuto alla prima lezione del corso «ChucK 101», ovvero il corso introduttivo al linguaggio di programmazione real-time dedicato alla musica di cui ho già parlato qui.

È la prima volta che programmi?

Nel caso in cui la risposta a questa domanda sia si, prima di cominciare ad avventurarci nei meandri del codice, è il caso di spendere due parole per mettere in chiaro alcune questioni fondamentali:

  1. Programmare non è semplice; richiede tempo per migliorarsi e un sacco di pazienza.
  2. Non copiare il codice! Mi rendo conto che la tentazione di fare un veloce copia-incolla del codice che troverai di seguito sia troppo forte ma, così facendo, non imparerai nulla. Inserire a mano, di volta in volta, le righe di codice ti darà la possibilità di imparare più in fretta il linguaggio di programmazione e di capire realmente quello che si sta facendo.
  3. Sperimenta. Questo è un concetto fondamentale: non basarti solo su quello che troverai scritto nei miei post. L’obiettivo è sperimentare: prova a sostituire dei valori, delle variabili, intere parti di codice, ecc… . Solo così facendo riuscirai a imparare a programmare in ChucK esplorandone tutte le possibilità.
  4. Debug. Ti potrà capitare che i tuoi programmi non funzionino. È normale, succede a tutti (anche ai programmatori più esperti) e succede di continuo. Talvolta gli errori sono dovuti a sviste banali: errori di digitazione, punti o virgole mancanti, ecc…, altre volte individuare il problema può essere un’attività lunga complessa. La cosa che devi imparare subito è capire e interpretare correttamente i messaggi di errore che ti vengono restituiti dal compilatore quando il programma non funziona. Prima imparerai a riconoscerle questi messaggi e le relative cause del problema, più semplice sarà effettuare il debug del programma.
  5. Copia gli altri e non cancellare mai niente. Molti programmatori rilasciano parti di codice liberamente e con licenze che ti permettono di copiare o modificare i loro programmi. Non reinventare la ruota ogni volta; cerca se qualcuno ha affrontato il problema prima di te, studia le loro soluzioni (ma non prenderle mai come oro colato perché potrebbero non essere aggiornate) e, se consentito, copia il loro codice. Non c’è modo migliore di imparare e migliorarsi che guardare come programmatori più esperti hanno risolto lo stesso problema. Ricorda di non cestinare mai i tuoi programmi, in futuro quelle porzioni di codice potrebbe sempre tornarti utile.
  6. Google è tuo amico. Quando sbatti la testa contro un problema che non riesci a risolvere, cerca su Google, è molto probabile che qualcuno l’abbia fatto prima di te e abbia già trovato la soluzione (e sia stato così gentile da condividerla da qualche parte).

Il software: miniAudicle

Il primo passo da compiere è quello di scaricare il software miniAudicle da questo indirizzo. L’ultima versione disponibile, al momento, è la 1.3.4.0. Il programma è diviso in tre finestre principali: Main Window (dove scriveremo il codice), Virtual Machine Monitor Window (il server che dobbiamo avviare ogni volta che vogliamo far girare un nostro programma), Console Monitor Window (finestra che si attiva quando avviamo la virtual machine e che ci mostra vari messaggi).

Main Window
Main Window
Virtual Machine Monitor Window
Virtual Machine Monitor Window
ChucK Console Monitor
Console Monitor Window

Hello World!

Normalmente il primo programma che si impara a scrivere, indipendentemente dal linguaggio utilizzato, si chiama “Hello World!”. Lo scopo di tale programma è quello di far scrivere sul monitor del computer queste due parole come output del programma.

Nella Main Window digitate:

<<<"Hello World!">>>;

Salvate il programma andando nel menu File > Save (scorciatoia Command + S). Dopodiché nella finestra Virtual Machine cliccate sul pulsante Start Virtual Machine e, infine, nella Main Window cliccate sul pulsante Add Shred (Command + “+”).

Se avete scritto tutto correttamente, dovreste ottenere un risultato come quello nell’immagine seguente:

ChucK Hello World

Dopo l’inizializzazione della Virtual Machine (con i relativi parametri di configurazione), potete notare che il programma ha restituito in output quello che volevamo: la scritta “Hello World!”.

Con questo semplice programma abbiamo imparato due cose importanti: la prima è che alla fine di ogni riga di istruzioni dobbiamo utilizzare il punto e virgola, la seconda è che per vedere scritto qualcosa nella finestra Console Monitor dobbiamo utilizzare il comando <<<” “>>>.

Hello Sine!

Siccome ChucK è un linguaggio di programmazione orientato alla musica, il nostro obiettivo è quello di produrre dei suoni. Mettiamo dunque da parte il nostro primo programma “Hello World” e concentriamoci sul nostro primo esperimento musicale: “Hello Sine!”.

Per non rendere questo post troppo lungo e noioso con questioni teoriche, sorvolerò alcune questioni di base sull’audio, le forme d’onda, ecc… .

L’obiettivo del programma sarà:

  1. Utilizzare un oscillatore con onda sinusoidale (la forma d’onda più semplice)
  2. Fare in modo che tale oscillatore sia collegato al convertitore digitale-analogico (ovvero quel componente che permette al computer di emettere dei suoni attraverso gli speaker)
  3. Assegnare un valore di gain (volume) all’oscillatore
  4. Assegnare un valore di frequenza all’onda sinusoidale
  5. Emettere un suono per 1 secondo

Il codice del nostro programma:

// Hello Sine
// Aprile 2014
SinOsc sine => dac;
0.7 => sine.gain;
440 => sine.freq;
1::second => now;

Una volta completata la digitazione, avviando la Virtual Machine e cliccando su Add Shred, il vostro computer emetterà un suono a 440Hz (la nota di riferimento che viene utilizzata dai musicisti per accordarsi).

Analizziamo il codice che abbiamo scritto: le prime due righe, precedute da //, sono semplicemente di commento. All’inizio del tuo percorso, ti consiglio di commentare il più possibile ogni passaggio, più migliorerai, più sarai in grado di valutare autonomamente quando sarà necessario scrivere un commento e quando no. Cosa molto importante: tutto ciò che è scritto nei commenti verrà completamente ignorato dal compilatore.

Con il comando SinOsc abbiamo richiamato un oggetto unit generator in grado di generare il suono di un’onda sinusoidale. Il nostro generatore l’abbiamo chiamato sine (ma avremmo potuto scegliere un nome qualsiasi) e, attraverso l’operatore =>, l’abbiamo collegato al dac (digital to analog converter).

Abbiamo assegnato il valore .7 al gain e 440 alla frequenza emessa dal nostro oscillatore. A differenza di molti linguaggi di programmazione, in ChucK si esprime prima il valore e poi la variabile a cui tale valore deve essere assegnata (e lo si fa utilizzando sempre l’operatore => che, come vedremo in futuro, sarà onnipresente nei nostri esercizi).

Come avrete intuito, le variabili sono legati all’oggetto di riferimento attraverso la sintassi oggetto.impostazione per cui dobbiamo utilizzare nomi efficaci e che abbiano senso. Per esempio, se avessimo assegnato all’oscillatore il nome «pippo» (SinOsc pippo => dac;) avremmo dovuto scrivere pippo.gain pippo.freq per assegnare correttamente i valori.

Infine, abbiamo detto al nostro programma di avanzare di un secondo nel tempo con il comando: 1::second => now;

Mi rendo conto che quest’ultima parte potrebbe non essere chiara al momento ma in futuro spiegherò esattamente come funziona la gestione del tempo in ChucK.

Compiti a casa

Per concludere questa prima lezione ti lascio con qualche spunto per divertirti un po’ nell’attesa della prossima lezione:

  • SinOsc ha prodotto un’onda sinusoidale, prova a utilizzare TriOsc (onda triangolare), SqrOsc (onda quadra) o SawOsc (onda a dente di sega)
  • Utilizza /* per aprire un commento di più righe e */ quando vuoi chiuderlo. Questo sistema tornerà molto utile in fase di debug per escludere, commentandole, le righe di codice non funzionante.
  • Prova a creare una breve composizione utilizzando solo ed esclusivamente le cose descritte fino a qui. Suggerimento: quando vuoi creare una “pausa”, devi impostare il valore del volume dell’oscillatore a 0. Ricordati di lasciare nei commenti un link alla tua composizione!

Un’introduzione a ChucK

L’introduzione dei computer in ambito creativo ha portato a un’evoluzione del significato abitualmente attribuito ai termini artista e musicista: il computer infatti, per moltissimi performer, è diventato indispensabile sia durante la fase creativa che live; ma possiamo davvero definirci «creativi» e non semplici «utilizzatori» di tecnologie sviluppate da altri?

Rispondere a questa domanda potrebbe non essere semplice e potremmo rischiare di finire in un loop nel caso in cui non fissassimo dei punti fermi: lo scopo di questo post (e di quelli che seguiranno) non è certo quello di spiegare come costruire un computer e programmare da zero un sistema operativo bensì di invogliare a spingersi un po’ più in profondità rispetto a quello che, normalmente, accade quando fruiamo di un programma di questo genere.

Utilizzare strumenti creati da altri è certamente una scorciatoia per realizzare velocemente le idee che abbiamo in mente ma questo comporta, necessariamente, rispettare dei limiti che ci vengono imposti da chi quel software l’ha creato. Alcuni artisti non amano avere questo tipo di barriere e, quindi, si sono rivolti al mondo della programmazione per poter analizzare più in profondità le possibilità che la tecnologia oggi può offrire.

Avere maggiore controllo sulla tecnologia ci permette di abbattere anche le barriere “di genere” e ci consente di unire più ambiti artistici. Uno dei maggiori trend in ambito sia tecnologico che musicale degli ultimi anni è proprio quello di combinare performance musicali ad altre discipline creative: danza, animazione, computer grafica, design, installazioni, ecc…

Cos’è ChucK?

ChucK è un linguaggio di programmazione open-source per sintetizzare suoni e creare musica in real-time sviluppato da Ge Wang, professore associato alla Stanford University e fondatore della start-up Smule (Ocarina per iPhone). A differenza degli altri linguaggi (CSound, SuperCollider, PureData e Max/MSP), ChucK si basa su un concetto fondamentale: il tempo. Come vedremo nei post che seguiranno, quando scriviamo un programma in ChucK dobbiamo sempre fare riferimento al tempo che, scorrendo, ci permette di generare suoni o sintetizzarli.

ChucK è un linguaggio di programmazione testuale; questo significa che per utilizzarlo dovremmo scrivere righe di codice, un modo davvero inusuale di fare musica. Personalmente l’ho trovato molto stimolante perché permette di approcciare un problema comune con una prospettiva diversa. All’inizio farete un po’ più di fatica ma, una volta superati i primi scogli, vi assicuro che vi divertirete.

Alcuni esempi

Per cominciare

ChucK è completamente gratuito; il primo passo da compiere è scaricare l’applicazione a questo indirizzo (è disponibile per Mac, Windows e Linux).

Lo scopo di questo post era introdurre ChucK; l’intento generale è quello di scrivere  nel corso delle prossime settimane e mesi una guida in italiano sull’utilizzo di questo linguaggio di programmazione.

Risorse

Per chi volesse partire “da subito” consiglio le seguenti risorse:

ChucK Documentation:
http://chuck.stanford.edu/doc/

Introduction to Programming for Musicians and Digital Artists:
https://www.coursera.org/course/chuck101

Programming for Musicians and Digital Artists (book):
http://www.manning.com/kapur/