Clase 2

// Taller de SuperCollider Básico

BUAP

 

Sesión 2

 06/20/09

   

 

*Formas básicas de producción de sonido con SC: generadores de ruido

*Síntesis de sonido básica: síntesis aditiva y síntesis por modulación de frecuencia.

*Filtros

*Interactividad: control con el mouse

*Ejercicios

 

Acá puedes bajar la clase en los formatos PDF y docx


 //Formas básicas de producción de sonido con SC: generadores de ruido

 

 En términos de física, el ruido es una señal aleatoria. Hay diferentes tipos de ruido que se clasifican dependiendo del comportamiento de su densidad espectral, es decir, dependiendo de la distribución de la potencia de las frecuencias en el espectro del ruido. Esta clasificación según la densidad espectral de un ruido recibe el nombre de color.

 

 White Noise

 Este nombre es una analogía a la “luz blanca” que contiene todos los colores en la misma intensidad y con una gran energía. Esta señal contiene todas las frecuencias y todas ellas con la misma potencia. El espectro del ruido blanco es plano.

 

 {WhiteNoise.ar (0.1) !2}.scope 

 

 Pink Noise

 También se conoce como “ruido 1/f” ya que su densidad espectral de potencia decae 3dB por octava. Se usa mucho como señal de prueba en ingeniería acústica. el espectro del ruido rosa es semejante al espectro medio acumulado de la música sinfónica o de instrumentos como el piano y el órgano.

 

 {PinkNoise.ar (0.9) !2}.scope 

 

 Brown Noise

 También se conoce como “Brownian Noise” o “ruido browniano”. Su PSD decae 6dB por octava, es decir que es directamente proporcional a 1/f**2. Su nombre no se debe al color marrón, sino a Robert Brown, el descubridor del “movimiento browniano”, ya que este ruido puede ser generado por un algoritmo que simula dicho movimiento.

 

 {BrownNoise.ar (0.9) !2}.scope 

 

 Dust

 Generador de impulsos aleatorios.

 

 {Dust.ar (2500) !2}.scope 

 

 //Abrir el archivo: supercollider/examples/demonstrations/SC2-examples_1.scd

 

//Síntesis de sonido básica: síntesis aditiva y síntesis por modulación de frecuencia.

 

 Vamos a usar una de las técnicas más sencillas para crear nuevos timbres. Esta técnica tiene como principio el uso de dos operadores básicos: multiplicación y suma.

 

Suma

 Al sumar dos señales obtenemos un timbre nuevo en donde se escucha claramente la personalidad de cada una. Esto recibe el nombre de síntesis aditiva. Las amplitudes de las señales se suman, así que hay que tener cuidado con que esta suma no sobrepase 1.0. 

 

 ==============

 {SinOsc.ar(2500, 0, 0.2)!2}.play

 

 {WhiteNoise.ar(0.1)!2}.play

 

 {SinOsc.ar(2500, 0, 0.2)+WhiteNoise.ar(0.1)!2}.play

 ==============

 

 Multiplicación

 Al multiplicar dos señales obtenemos un timbre complejo. Esta técnica se relaciona con la Amplitud Modulada y la Modulación de Anillo.

 

 ==============

  {SinOsc.ar(2500, 0, 0.7)*WhiteNoise.kr(0.8)!2}.play

 

  {WhiteNoise.ar(0.8)*SinOsc.kr(2500,0,0.7)!2}.play

 

  {WhiteNoise.kr(0.8)*SinOsc.ar(2500,0,0.7)!2}.play

 

  {PinkNoise.ar (0.3)*SinOsc.kr(2000,0,0.9)!2}.play

 

  {(Pulse.ar(40,0.01,0.9)*SinOsc.kr(275,0,0.4,0.5)*WhiteNoise.kr(0.9))!2}.scope

 

  {(Pulse.ar(40,0.01,0.9)*SinOsc.kr(275,0,0.4,0.5)*WhiteNoise.kr(0.9)+Saw.ar(100,0.1))!2}.scope

 ==============

 

 //EJERCICIOS

 

 Completar los espacios en blanco

/* 1 */ {SinOsc.ar(1360,0,0.6)*WhiteNoise.kr(0.3)}.scope
/* 2 */ {LFTri.ar(60,0.5)*SinOsc.kr(780,0,0.34)}.scope
/* 3 */ {SinOsc.ar(600,0,0.7)*SinOsc.kr(1240,0,0.7)}.scope
/* 4 */ {___.ar(0.3)*___.kr(3,0,0.9)}.scope
/* 5 */ {Pulse.ar(__,__,0.5)*___.kr(100,___)}.scope
/* 6 */ {___.ar(30,0.3)*___.kr(0.6)}.scope
/* 7 */ {LFTri.ar(30,0.1,0.3)*___.kr(0.6)*___.kr(10,0,0.4,0.6)}.scope
/* 8 */ {___.ar(302,0.3)*___.kr(10.6,0,0.6)*___.kr(0.710)}.scope
/* 9 */ {SinOsc.ar(___,0,0.5)*SinOsc.kr(___,0,0.5,0.5)}.scope
/* 10 */ {___.ar(___,0.4)*WhiteNoise.kr(___)*___.ar(1200,0.4)*SinOsc.kr(__,0,0.6)}.scope
/* 11 */ {(___.ar(___)*___.kr(0.2))+Saw.ar(___,0.041)}.scope
/* 12 */ {(Pulse.ar(40,0.01,0.3)*___.kr(___,0,0.4,0.5)*WhiteNoise.kr(___))+____.ar(___,0.4)}.scope
/* 13 */ {((___.ar(0.5)*Dust.kr(___))+PinkNoise.ar(___))*SinOsc.kr(___,0,0.4,0.5)}.scope
/* 14 */ {Saw.ar(___,0.3)+Saw.ar(___,0.3)}.scope
/* 15 */ {((Saw.ar(460,0.3)+Pulse.ar(462,___,0.3))*Dust.kr(___))+LFTri.ar(___,0.1,___)}.scope
/* 16 */ {___.ar(14000,0,0.9)*Dust.kr(___)}.scope
/* 17 */ {___.ar(70,0,__)*Dust.kr(___)}.scope
/* 18 */ {SinOsc.ar(___,0,0.3)+___.ar(___,0,0.3)+SinOsc.ar(___,0,0.2)+___.ar(50,0,0.7)}.scope
/* 19 */ {LFTri.ar(___,0,0.5)*SinOsc.kr(___,0,0.7)}.scope
/* 20 */ {___.ar(130,0.2)+___.ar(100,0,0.3)+___.ar(0.031)}.scope

 

 

//Filtros

 

Un filtro es un sistema que realiza un proceso de discriminación de una señal de entrada para obtener variaciones en su salida. Un filtro de audio está diseñado para dejar pasar determinadas regiones de frecuencia y para no dejar pasar otras. En los filtros que usaremos, el primer argumento indica la señal que será filtrada y el segundo argumento es su frecuencia de corte. Los tres filtros que veremos a continuación pueden funcionar tanto con .ar como con .kr. La condición al usarlos es que la señal que se quiera filtrar tenga el mismo rate que el filtro.

 

HPF High Pass Filter 

Este es un filtro que permite el paso de frecuencias altas y atenúa las frecuencias más abajo de la frecuencia de corte. Por ejemplo, si decidimos que la frecuencia de corte sea 700 Hz, nuestro filtro dejará pasar todas las frecuencias más altas que 700 Hz.

 

Sus argumentos son:

 

in: señal que filtraremos

freq: frecuencia de corte

mul: multiplicación

add: adición

 

{HPF.ar(WhiteNoise.ar(0.1), 7030)}.scope // Aqui un WhiteNoise es filtrado por un pasa altos dejando pasar frecuencias arriba de los 7030 Hz

 

LPF Low Pass Filter

Al contrario del filtro pasa altos, el pasa bajos permite el paso de frecuencias abajo de la frecuencia de corte y atenúa las que están arriba de ella. Los argumentos son los mismos que los del HPF.

 

{LPF.ar(WhiteNoise.ar(0.1),7030)}.scope // Aqui lo contrario: pasan las frecuencias debajo de los 7030 Hz

 

BPF Band Pass Filter

El filtro pasa bandas permite el paso de cierto rango de frecuencias y atenúa o rechaza las frecuencias que estén fuera de ese rango. Puede verse como la combinación de un HPF y un LPF. El rango de frecuencias se determina por el ancho de banda. La frecuencia que está en el centro de este ancho de banda es la frecuencia de corte. Por ejemplo: si determinamos que nuestra frecuencia de corte sea 1000 Hz y el ancho de banda 200 Hz, podremos saber cuál es el rango de frecuencia que dejaremos pasar usando la siguiente fórmula:

 

cota inferior = frecuencia de corte – ancho de banda/2

 

1000 – (200/2)

 

cota superior = frecuencia de corte + ancho de banda/2

 

1000 + (200/2)

 

//La cota superior es la frecuencia límite superior y la cota inferior es la frecuencia límite inferior.

 

Si sabemos cuáles son las cotas inferior y superior que queremos, entonces podemos obtener el ancho de banda y la frecuencia de corte con la siguiente fórmula:

 

ancho de banda = cota superior – cota inferior

 

1100 – 900

 

frecuencia de corte = cota superior – ancho de banda/2

1100- (200/2)

 

o

frecuencia de corte = cota inferior + ancho de banda/2

900 + (200/2)

 

 

El BPF no es el único filtro que usa un ancho de banda. En los filtros de este tipo el ancho de banda no puede escribirse como un argumento. Para establecer el ancho de banda, SC utiliza el factor de calidad del filtro, que es un parámetro que mide la relación de energía que dispersa el filtro y la que almacena. Este factor es conocido como Q y es igual a la frecuencia de corte/ancho de banda. Entonces, en vez del ancho de banda, usamos el recíproco de Q, ya que esto le ahorra al programa una división adentro del UGen. El recíproco de Q se representa así Q/1 = 1/Q. Por consiguiente:

 

rq= ancho de banda /frecuencia de corte.

 

Sus argumentos son:

in: señal de entrada

freq: frecuencia de corte en Hz

rq: recíproco de Q, es decir el ancho de banda / frecuencia de corte.

mul y add

 

{ BPF.ar(WhiteNoise.ar(0.1), 7000, 700/7000)}.scope // El tercer argumento del pasa banda es el reciproco de q.

 

 

En este ejemplo tenemos ancho de banda=700 y frecuencia de corte=7000.

700/7000

 

=0.1

Por lo tanto rq=0.1

 

A veces es más rápido escribir el numero decimal que el quebrado:

 

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 0.1)}.scope

 

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 1)}.scope 

 

//usando quebrados, de qué otra forma puede escribirse el código anterior?

 

Si tenemos que 1 = ancho de banda / frecuencia de corte = rq, entonces sabemos que ancho de banda=frecuencia de corte / rq.

Y si frecuencia de corte = 7030,

entonces rq = 7030 / 7030.

Por lo tanto sabemos que la línea de código anterior se puede escribir también de la siguiente forma:

 

{ BPF.ar(WhiteNoise.ar(0.1), 7030, 7030/7030)}.scope

 

//Interactividad: control con el mouse

 

Una forma de controlar los argumentos de los UGens en SuperCollider es através de las Clases MouseY, MouseX y MouseButton. Estas clases son UGens de control por lo que trabajan con el mensaje .kr. Los argumentos principales de los UGens MouseY y MouseX son el valor mínimo y el valor máximo que queremos obtener al mover nuestro mouse. En MouseButton los argumentos son los valores que queremos darle al botón del mouse cuando lo apretamos y cuando lo soltamos. 

 

MouseX.kr(0,100) // nos da números desde 0 (cuando el mouse está totalmente a la izquierda) hasta 100 (cuando el mouse está en el extremo derecho).

 

MouseY.kr(0,100) // nos da números desde 0 (cuando el mouse esta completamente arriba) hasta 100 (cuando el mouse está totalmente abajo).

 

MouseButton.kr(0,1) // Cuando el botón no está apretado tenemos el valor 0 y cuando se aprieta, el valor es 1.

 

==================

 

{SinOsc.ar(MouseY.kr(1000,100))!2}.scope  // Nos permite hacer un barrido desde la frecuencia 100 Hz cuando el mouse está abajo, hasta 1000 cuando el mouse está arriba.

 

{SinOsc.ar(400,0,MouseX.kr(0,1))}.scope  // Amplitud (volumen) 0 cuando el mouse está en el extremo izquierdo, hasta 1 cuando el mouse está en el extremo derecho.

 

{SinOsc.ar(MouseX.kr(1000,100),0,MouseY.kr(0,1))}.scope // Mezclando los dos ejemplos anteriores con MouseY y MouseX

 

{Pulse.ar(MouseY.kr(10000,20),MouseX.kr(0.001,0.5),MouseButton.kr(0,1))}.scope

 

Los mismos ejemplos de filtros usando la clase MouseY y MouseX

 

{HPF.ar(WhiteNoise.ar(0.1), MouseY.kr(10000,1000))}.scope

 

{LPF.ar(WhiteNoise.ar(0.1), MouseX.kr(10000,100))}.scope

 

{BPF.ar(WhiteNoise.ar(0.1), MouseY.kr(10000,1000), 0.05)}.scope

 

{BPF.ar(WhiteNoise.ar(0.5), 130, MouseX.kr(0.05,1.5))}.scope

 

{BRF.ar(WhiteNoise.ar(0.1), MouseY.kr(10000,1000), MouseButton.kr(0,1))}.scope

 

{BRF.ar(WhiteNoise.ar(0.1), 7030, MouseX.kr(0.05,1.5))}.scope

 

//EJERCICIOS

 

/* 1 */ {LPF.ar(BrownNoise.ar(0.5),160)}.scope

 

/* 2  */ {HPF.ar(Pulse.ar(10,0.75)*WhiteNoise.ar(1),10000)}.scope

 

/* 3  */ {Saw.ar(10,0.75)*BPF.ar(WhiteNoise.ar(1),10000)}.scope

 

/* 4  */ {_______.ar(Saw.ar(2,0.6),3000,100/3000)+BPF.ar(_______.ar(3,0.4),_______,50/500)}.scope

 

/* 5  */ {LFTri.ar(1,0,1)*LPF.ar(_______.ar(30,0.1,1),1000)}.scope

 

/* 6  */ {Pulse.ar(117,_______.kr(0.5,0.01),0.5)}.scope

 

/* 7  */ {_______.ar(MouseX.kr(60,800),0,0.6)}.scope

 

/* 8  */ {_______.ar(_______.ar(100),MouseY.kr(15000,160),60/MouseY.kr(15000,160))}.scope

 

/* 9  */ {Pulse.ar(_______.kr(5,20))_______(SinOsc.ar(10000,0,0.6)_______SinOsc.ar(90,0,0.6))}.scope

 

/* 10 */ {Pulse.ar(MouseY.kr(110,90),_______,0.5)*_______.ar(100,0.1,0.5)}.scope

Creative Commons License
Taller de SuperCollider Básico by https://basicsupercollider.wordpress.com is licensed under a Creative Commons Attribution-Noncommercial 2.5 Mexico License.

10 Responses to “Clase 2”

  1. […] Acá pueden ver y bajar nuestra segunda clase.  No olviden que esta semana tenemos varios ejercicios para completar. Prueben diferentes UGens en […]

  2. ok, ya baje la segunda clase cualquier duda te estaré molestando
    je je, muchas gracias y saludos

  3. Súper, David! y no es ninguna molestia, pregunta lo que necesites preguntar. Abrazo!

  4. para cmpletar informacion de todo lo que vamos viendo conozco otro sitio acerca de investigacion electroaucstica y viene muy completo y lo considero más serio que wikipedia porue hasta bibliografía trae y en varios idiomas!!! la direccion es http://www.ears.dmu.ac.uk/ HASTA PRONTO

  5. Muchas gracias!!! está bien interesante el sitio. Ya mismo lo pongo en nuestros links🙂

  6. WOW! realmente está buenísimo el sitio de EARS, Isaac! de nuevo muchas gracias! además está enfocado a músicos, lo cual nos cae súper bien.

  7. como le doy play? no oigo nada !!

  8. Pedro de la Barra Says:

    Tengo una pregunta en relación a la síntesis aditiva. ¿Cómo podrías generar white noise y brown noise por medio únicamente de una síntesis aditiva con supercollider?

  9. el gato del friki marquez Says:

    hey… muchas gracias por subir un curso tan bueno.
    estos gestos ayudan a las personas a poder avanzar en sus proyectos.
    buen gesto

    • Me alegra mucho que te ayude! acá estamos para cualquier pregunta. También les recomiendo unirse al grupo SuperColliderMX de facebook, donde resolvemos dudas respecto a SC en español.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: