Bienvenido a Sonic Pi. Espero que estés tan emocionado por comenzar a hacer sonidos sorprendentes como yo lo estoy por enseñarte a hacerlos. Será realmente divertido. Aprenderás sobre música, síntesis, programación, composición, interpretación y mucho más.
Pero espera, ¡qué maleducado soy! Deja que me presente - soy Sam Aaron - el creador de Sonic Pi. Puedes encontrarme en Twitter @samaaron y estaré encantado de saludarte. Quizás te interese saber más de mis Performances de Live Coding donde programo en vivo y en directo con Sonic Pi.
Si tienes algunas observaciones o ideas para mejorar Sonic Pi - por favor pásamelas -, los comentarios son bienvenidos. Nunca se sabe, ¡tu idea podría ser incluida como una importante funcionalidad!
Este tutorial está dividido en secciones agrupadas por categoría. Lo he escrito para tener una fácil progresión de principio a fin, siéntete libre de saltar de una sección a otra cuanto te apetezca. Si piensas que hay algo que falta, házmelo saber y lo tendré en cuenta para versiones futuras.
Por último, observar a otros haciendo live-coding es una excelente manera de aprender. Yo lo hago regularmente en directo por https://youtube.com/samaaron, así que pásate por allí, salúdame y hazme muchas preguntas :-)
OK, comencemos…
Uno de los aspectos más excitantes de Sonic Pi es la posibilidad de escribir y modificar código para hacer música en directo, como lo harías al tocar una guitarra. Esto significa que con algo de práctica podrás usar Sonic Pi en directo.
Antes de entrar en detalle de cómo funciona Sonic Pi, me gustaría enseñarte que es programar en directo. No te preocupes si no entiendes mucho (o nada) de esto. Simplemente siéntate y disfruta …
Para empezar, copia el siguiente código en un buffer vacío:
live_loop :flibble do
sample :bd_haus, rate: 1
sleep 0.5
endAhora, presiona el botón “Ejecutar” y escucharás una batería con un ritmo rápido. Si en cualquier momento deseas parar el sonido, sólo debes presionar el botón “Parar”. Pero no lo pares, aún… antes sigue los siguientes pasos:
Asegúrate que el sonido de batería sigue sonando Cambia el valor “sleep” de “0.5” a algo más alto, por ejemplo “1”. Presiona de nuevo el botón “Ejecutar” Fíjate como ha cambiado la velocidad del bombo. Por último, recuerda este momento, esta es la primera vez que has programado en tiempo real con Sonic Pi y seguro que no será la última…
Ok, eso fue fácil. Añadamos algo a la mezcla. Encima de sample :bd_haus añade la línea sample :ambi_choir, rate: 0.3. Tu código debería ser así:
live_loop :flibble do
sample :ambi_choir, rate: 0.3
sample :bd_haus, rate: 1
sleep 1
endAhora vamos a jugar. Cambia valores, ¿qué pasa cuando usas valores altos, bajos o negativos? Mira lo que pasa cuando cambias el valor rate: por :ambi_choir ajústalo mínimamente (digamos a 0.29). ¿Qué pasa si pones un valor muy bajo para sleep? prueba a hacerlo sonar tan rápido que tu computadora se cuelgue con un error (si eso sucede, simplemente elige un valor más alto para sleep y presiona Ejecutar de nuevo).
Intenta comentar una de las líneas del sample, añadiendo un # al comienzo:
live_loop :flibble do
sample :ambi_choir, rate: 0.3
# sample :bd_haus, rate: 1
sleep 1
end¿Te das cuenta como le dice al ordenador que lo ignore, y así no lo oímos? Esto se llama “comentar”. En Sonic Pi podemos usar comentarios para quitar y añadir cosas a la mezcla.
Por último, te dejo con algo divertido con lo que jugar. Toma el siguiente código y cópialo en un buffer vacío. Por el momento no intentes comprender demasiado más que darte cuenta que hay dos bucles - lo que significa que hay dos eventos al mismo tiempo - experimenta y juega. Te dejo algunas sugerencias:
Prueba cambiando el valor en azul de rate: para escuchar cambios en el sample.
Prueba cambiando los tiempos de sleep y presta atención a cómo ambos bucles dan vueltas a diferentes valores.
Oberva que pasa quitando el comentario de la línea de ejemplo (quita #) y disfruta del sonido de la guitarra tocada al revés.
Prueba cambiar cualquiera de los valores azules mix: a números entre 0 (no en la mezcla) y 1 (totalmente en la mezcla).
Recuerda que debes presionar ‘Ejecutar’ para escuchar el cambio en el próximo bucle. Si termina siendo un lío, no te preocupes - dale a ‘Parar’, borra el código del buffer y pega una nueva copia del ejemplo para volver a empezar. Cometiendo errores es como aprenderás más rápidamente.
live_loop :guit do
with_fx :echo, mix: 0.3, phase: 0.25 do
sample :guit_em9, rate: 0.5
end
# sample :guit_em9, rate: -0.5
sleep 8
end
live_loop :boom do
with_fx :reverb, room: 1 do
sample :bd_boom, amp: 10, rate: 1
end
sleep 8
endAhora, sigue tocando y experimentando hasta despertar tu curiosidad y te preguntes qué más puedes hacer. Ya estás listo para leer el resto del tutorial.
¿A qué estás esperando?
Sonic Pi tiene una interfaz sencilla para programar música. Echemos un vistazo a esto.
A - Controles de Ejecución B - Controles de edición C - Información y Ayuda D - Editor de código E - Panel de Preferencias F - Visor de Registros G - Sistema de Ayuda H - Visor de Registros I - Cue Viewer
Estos botones rosados son los principales controles para comenzar y parar sonidos. El botón de Ejecutar sirve para iniciar la ejecución del código y Parar para parar todo código en Ejecución, Guardar para guardar el código a un archivo externo y Grabar para crear una grabación (archivo WAV) de los sonidos ejecutándose.
Estos botones naranjas te permiten manipular el editor de código. Los botones de Tamaño + y Tamaño -* te permiten aumentar y disminuir el tamaño del texto.
Estos botones azules te dan acceso a información, ayuda y preferencias. El botón Info abre la ventana informativa, la cual contiene información del propio programa Sonic Pi - el equipo base, historia, contribuyentes y la comunidad. El botón de Ayuda muestra u oculta el sistema de ayuda y el botón Preferencias activa la ventana de preferencias, que te permite controlar algunos parámetros básicos del sistema.
Esta es el área donde escribirás tu código y compondrás/ejecutarás música. Es un sencillo editor de texto donde puedes escribir, borrar, cortar, pegar, etc. Piensa que es una versión simplificada de Word o Google Docs. El editor colorea las palabras automáticamente, basado en su significado para el código. Al principio, esto puede parecer extraño, pero pronto lo encontrarás muy útil. Por ejemplo, sabrás que algo es un número, porque es de color azul.
Sonic Pi permite cambiar ciertos parámetros accesibles a través del botón preferencias . Este botón cambia la visibilidad del panel de preferencias, el cual incluye un número de opciones a ser cambiadas. Por ejemplo forzar el modo mono, invertir el estéreo, cambiar a vista/no vista de la bitácora, mando de volumen y un selector de audio para la Raspberry Pi.
Cuando ejecutas un código, el visualizador del log muestra información de lo que está haciendo el programa. Predeterminado está el que veas un mensaje por cada sonido que crees con el tiempo exacto al que fue disparado el sonido. Esto es muy útil para depurar código y entender qué es lo que está haciendo.
Finalmente, una de las partes más importantes de la interfaz de Sonic Pi es el sistema de ayuda que aparece en la parte baja de la ventana. Esta puede ser activada o desactivada al apretar el botón azul «Ayuda». El sistema de ayuda contiene información de todos los aspectos de Sonic Pi incluído este tutorial, listado de sintetizadores disponibles, muestras (samples), ejemplos, efectos y una lista de todas las funciones que Sonic Pi provee para codificar música.
El visor de alcance le permite ver el sonido que esta escuchando. Usted puede ver fácilmente que la onda de la sierra parece una sierra y que el pitido básico es una curva de onda senoidal. También puede ver la diferencia entre sonidos fuertes y silenciosos por el tamaño de las líneas. Hay 3 alcances para jugar - el defecto es un alcance combinado para los canales izquierdos y derechos, hay un alcance estéreo que dibuja un alcance separado para cada canal. Finalmente hay un alcance de curva Lissajous que mostrará la relación de fase entre los canales izquierdo y derecho y le permitirá dibujar imágenes bonitas con sonido (https://en.wikipedia.org/wiki/Lissajous_curve).
All internal and external events (called cues in Sonic Pi) are automatically logged in the Cue Viewer. For example, if you have a MIDI controller connected and press one of its buttons, you’ll see a new cue event in the Cue Viewer telling you the name of the controller and which button you pressed. Once you’ve mastered the basics of making and producing sounds, you’ll start to want to cue sounds or whole sections of sounds based on events such as these. A cue event is just an indication that something happened. For example, every time a live loop spins round, it sends a cue event out which is logged in the Cue Viewer. Also, external events such as MIDI messages from connected MIDI equipment and OSC messages from other programs or computers are also displayed in the Cue Viewer. It is also possible to directly generate cue events using the cue function. Anything that appears in the Cue Viewer can be used to trigger something happening. This is covered in more detail in Sections 10 to 12 of this tutorial.
Sonic Pi te incita a aprender computación y música a través del juego y la experimentación. Lo más importante es que te diviertas y sin darte cuenta, estarás aprendiendo a programar, componer y reproducir.
Hablando de eso, déjame darte un consejo, aprendido a través de mis años programando música en vivo: «no hay errores, sólo oportunidades». Esto es algo que he escuchado a menudo en relación al jazz, pero funciona igualmente bien en el live-coding. No importa lo experimentado que seas -de completo principiante a un experimentado Algoraver, alguna vez ejecutarás código que salga de manera inesperada. Puede que suene increíblemente bien, en cuyo caso continúa con él. O puede que suene mal o fuera de lugar. Pero no importa– Lo que importa es lo que hagas con él. Toma el sonido, manipúlalo y conviértelo en algo alucinante. El público se volverá loco.
Cuando estás aprendiendo es tentador querer hacer cosas ya. Sin embargo, mantén ese deseo como un objetivo para después. Por ahora, piensa en lo más simple que puedas escribir sea divertido y satisfactorio, que sea un simple paso para ese increíble objetivo que tienes en mente. Una vez tengas una idea de ese simple paso, intenta y constrúyelo, juega y mira qué nuevas ideas te trae. En poco tiempo estarás demasiado ocupado divirtiéndote y teniendo un progreso real.
Sólo asegúrate de compartir tu trabajo con los demás!
De acuerdo, ya esta bien de introducciones - hagamos algo de sonido.
En esta sección cubriremos las bases de desencadenar y manipular un sintetizador, que no es más que una palabra rebuscada para algo que produce sonidos. Típicamente los sintetizadores son bastante complicados de usarse - especialmente los análogos con tantos cables para unir los módulos. Sin embargo, Sonic-Pi te da mucho de ese poder en una manera mucho más sencilla.
No te confundas con la sencillez del interfaz de Sonic-Pi. Puedes llegar a manipular con mucha profundidad el sonido, si eso te interesa. Mantente atento…
Dale una mirada al siguiente código:
play 70Así comienza todo. Adelante, copia y pega en la ventana superior de la aplicación (ese espacio grande en blanco debajo del botón Ejecutar) Ahora, presiona ‘Ejecutar’…
Intenso. Presiónalo otra vez, otra vez, otra vez y otra vez…
Woah, loco, estoy seguro que podrías seguir así por el resto del día. Pero espera, antes de perderte en un infinito bucle de sonidos, intenta cambiando el número:
play 75¿Escuchas la diferencia? Intenta con un número menor:
play 60Los números bajos crean sonidos más graves, mientras que los altos crean sonidos más agudos. Exactamente como en un piano, las teclas en la parte baja del piano (a la izquierda) hacen sonar notas más graves, y las teclas de la parte alta del piano (a la derecha) hacen sonar notas más agudas.
Resulta que el do de la cuarta octava (C en la notación inglesa) está identificado por el número 60. Por eso, play 60 hace sonar el do de la cuarta octava. Para hacer sonar la siguiente tecla hacia la derecha, tienes que sumar 1 a 60 y entonces escribir play 61, que en este caso es la tecla negra del do sostenido (o el re bemol). Para hacer sonar un re, sería la correspondiente tecla hacia la derecha, y debes escribir play 62.
No te preocupes si nada de esto significa algo para tí, que así fue también cuando yo comenzaba. Lo que importa es que sepas que los números menores significan sonidos más graves que los números mayores.
Si tocar una nota es divertido, tocar varias al mismo tiempo lo es aún más. Pruébalo:
play 72
play 75
play 79Jazzy! cuando escribes múltiples plays, todos se tocan al mismo tiempo. compruébalo tú mismo - ¿cuáles suenan bien juntos, cuales suenan mal?, experimenta y encuentra por tí mismo.
Si tocar notas y acordes es divertido, pero ¿que tal una melodía? ¿qué tal si queremos tocar notas en diferentes momentos? ¡Fácil! sólo debes poner un sleep entre las notas:
play 72
sleep 1
play 75
sleep 1
play 79¡qué adorable pequeño arpegio! Entonces, ¿qué significa el 1 en sleep 1? Bien, significa la duración de la interrupción. Realmente significa esperar por un pulso, aunque por ahora podemos pensar que significa detenerse por espacio de 1 segundo. Así, ¿cómo haríamos para que el arpegio suene más rápido? Bueno, necesitaríamos usar valores de ‘sleep’ menores. ¿qué tal, por ejemplo 0.5:
play 72
sleep 0.5
play 75
sleep 0.5
play 79¿Notaste que se ejecutaron más rápido? ahora prueba tú mismo cambiando los valores, usando diferentes tiempos y notas.
Una cosa a probar es tocar notas como play 52.3 y play 52.63. No hay necesidad alguna de usar notas enteras. Toca, prueba y diviértete.
Para aquellos de vosotros que poseáis conocimientos de notación musical (no importa si no, no es absolutamente necesario para divertirte) quizás quieras escribir una melodía usando nombres de notas como C y F# en vez de números. Sonic Pi tiene todo eso cubierto. Puedes hacer lo siguiente:
play :C
sleep 0.5
play :D
sleep 0.5
play :ERecuerda poner los dos puntos ‘:’ delante del nombre de la nota, para que se ponga color rosa. también puedes especificar la octava, añadiendo un número delante de la nota:
play :C3
sleep 0.5
play :D3
sleep 0.5
play :E4Si quieres hacer una nota aguda, añádele una ‘s’ al nombre de la nota así:play :Fs3 y si quieres hacer una nota plana, añádele una b así play :Eb3.
Ahora, “enloquece” y diviértete con tus propias tonadas.
Asimismo como Sonic Pi te permite controlar cuál nota tocar o cuál muestra desencadenar, también provee un completo rango de opciones para pulir y controlar los sonidos. En este tutorial cubriremos muchos de estos y existe una gran documentación para cada uno en el sistema de ayuda. Sin embargo, por ahora introduciremos dos de los más útiles: amplitude y pan. Miremos primero cuales son las opciones.
Sonic Pi apoya la noción de opciones (opts, abreviando) para sus sintetizadores. Opts son controles que pasas a play los cuales modifican y controlan aspectos del sonido que oyes. Cada sintetizador tiene su propio set de opts para sintonizar su sonido. Sin embargo, hay sets comunes de opts que comparten muchos, como amp: y sobre opts (cubiertas en otra sección).
Las Opts tienen dos partes principales, su nombre (el nombre del control) y su valor (el valor al que pondrás el control). Por ejemplo, puedes tener un control llamado ‘cheese:’ y querer ponerlo con un valor de 1.
Los opts se pasan a las llamadas a play por medio del uso de una coma , y después el nombre del opt, tal como amp: (no olvides los dos puntos :) y después un espacio y el valor del opt. Ejemplo:
play 50, cheese: 1(Nota que cheese: no es un opt válido, lo usamos sólo como ejemplo).
Puedes pasar múltiples opts separados por comas:
play 50, cheese: 1, beans: 0.5El orden de los opts no importa, el siguiente será igual al anterior:
play 50, beans: 0.5, cheese: 1Si un Opt no es reconocido por el sintetizador, simplemente es ignorado (como en el caso de cheese y beans ¡los cuales son nombres ridículos, obviamente!)
Si accidentalmente utilizas el mismo opt dos veces con diferentes valores, el último gana. Por ejemplo, beans: aquí tendrá el valor de 2 y no el de 0.5:
play 50, beans: 0.5, cheese: 3, eggs: 0.1, beans: 2Muchas cosas en Sonic Pi aceptan opts, sólo debes pasar tiempo aprendiendo cómo usarlas e irás bien. Ejecutemos nuestro primer opt: amp:.
Amplitud es una representación computarizada del volumen de un sonido. Una alta amplitud produce un sonido de alto volumen y baja amplitud produce sonido de bajo volumen. Así como Sonic Pi utiliza números para representar tonos y tiempos, usa números para representar la amplitud. Una amplitud de 0 es silencio (escucharás nada) y amplitud de 1 es volumen normal. Puedes utilizar volumen a amplitudes mayores a 2, 10, 100. Sin embargo, debes tener en cuenta que cuando la amplitud de todos los sonidos se vuelve muy alta, Sonic Pi utiliza un compresor para asegurar que no lleguen a tan alto que dañen tus oídos. Esto puede hacer que los sonidos sean extraños. Intenta con amplitudes bajas, por ejemplo en el rango de 0 to 0.5 para evitar compresión.
Para cambiar la amplitud de un sonido, utiliza el opt amp:. Por ejemplo, para tocar a la mitad de la amplitud cámbialo a 0.5:
play 60, amp: 0.5Para hacerlo al doble de amplitud 2:
play 60, amp: 2El opt amp: sólo modifica la llamada para el play al que está asociado. Así, en este ejemplo, la primera llamada para tocar es a mitad de volumen y la segunda es a la predeterminada (1):
play 60, amp: 0.5
sleep 0.5
play 65Por supuesto que puedes usar diferentes valores de amp: para cada llamada a play:
play 50, amp: 0.1
sleep 0.25
play 55, amp: 0.2
sleep 0.25
play 57, amp: 0.4
sleep 0.25
play 62, amp: 1Otro concepto divertido de usar es el paneo pan: el cual controla el paneo de un sonido en estéreo. Panear un sonido a la izquierda, significa que lo escucharás en la bocina izquierda, panearlo a la derecha, significa que lo escucharás de la bocina derecha. Para nuestros valores, tenemos -1 para representar completamente a la izquierda, 0 para representar el centro y 1 para representar completamente a la derecha. Claro, eres libre de usar cualquier valor en medio de -1 y 1 para controlar la posición exacta de tu sonido.
Toquemos un sonido desde la bocina izquierda:
play 60, pan: -1ahora que salga de la bocina derecha:
play 60, pan: 1Finalmente, pongámoslo de nuevo al centro (predeterminado):
play 60, pan: 0¡Ahora diviértete cambiando las amplitudes y paneos de tus sonidos!
Hasta ahora nos hemos divertido mucho sólo con sonidos. Sin embargo, de seguro ya comienzas a cansarte del sonido básico de pitidos. ¿es eso todo lo que Sonic-Pi tiene para ofrecer? Tiene que haber más que tocar pitidos. Sí, hay mucho más y lo exploraremos en esta sección con el impresionante rango de sonidos que Sonic Pi tiene para ofrecer.
Sonic Pi cuenta con varios instrumento llamados synths (una abreviación de sintetizadores). Mientras que los muestreos representan sonidos pre-grabados, los sintetizadores son capaces de generar nuevos sonidos dependiendo de cómo los controles (lo cual exploraremos más adelante en el tutorial). Los sintetizadores de Sonic Pi son poderosos y expresivos, y seguro que te divertirás tocando y explorándolos. Primero, aprendamos a seleccionar el synth que queremos usar.
Un sonido divertido es el de la onda sierra - probémoslo:
use_synth :saw
play 38
sleep 0.25
play 50
sleep 0.25
play 62
sleep 0.25Probemos otro sonido - prophet:
use_synth :prophet
play 38
sleep 0.25
play 50
sleep 0.25
play 62
sleep 0.25¿Qué tal si combinamos ambos sonidos? Pongamos uno después del otro:
use_synth :saw
play 38
sleep 0.25
play 50
sleep 0.25
use_synth :prophet
play 57
sleep 0.25Now multiple sounds at the same time (by not sleeping between successive calls to play):
use_synth :tb303
play 38
sleep 0.25
use_synth :dsaw
play 50
sleep 0.25
use_synth :prophet
play 57
sleep 0.25Debes notar que el comando use_synth sólo afecta a las siguientes llamadas a play. Piensa en él como un gran conmutador - nuevas llamadas a play tocarán el sintetizador que esté en uso. Puedes cambiar el conmutador a un nuevo sintetizador con use_synth.
Para saber qué sintetizadores tiene Sonic Pi, échale un vistazo a la opción Sintetizadores en el menú a la izquierda (a la izquierda de Efectos). Hay más de 20 entre los que elegir. Aquí están algunos de mis favoritos:
:prophet
:dsaw
:fm
:tb303
:pulse
Ahora prueba a cambiar los sintetizadores durante la ejecución de tu música. Diviértete combinando sintetizadores para hacer nuevos sonidos así como utilizando diferentes sintetizadores para diferentes secciones de tu música.
En una sección anterior, vimos cómo utilizar el comando sleep para controlar cuándo disparar sonidos. Sin embargo, aún no hemos podido controlar la duración de nuestros sonidos.
Con el fin de darnos una simple pero poderosa manera de controlar la duración de nuestros sonidos, Sonic Pi proporciona el concepto de una envolvente de amplitud ADSR (más adelante en esta sección trataremos qué significa ADSR). Una envolvente de amplitud ofrece el control de dos aspectos muy útiles:
control sobre la duración del sonido control sobre la amplitud del sonido
La duración es la longitud del sonido. Una mayor duración significa que escucharás el sonido por más tiempo. Todos los sonidos de Sonic Pi tienen una envolvente de control de la amplitud, y la duración total de la envolvente es la duración del sonido. Por lo tanto, al controlar la envolvente controlas la duración.
La envolvente ADSR no sólo controla la duración, también te permite control fino de la amplitud del sonido. Todos los sonidos audibles comienzan y terminan en silencio, conteniendo partes no-silentes en medio. Las envolventes permiten deslizar y mantener la amplitud de las partes no-silentes. Es como darle instrucciones a alguien sobre cómo subir y bajar el volumen del amplificador de una guitarra. Por ejemplo, puedes pedirle a alguien “comienza en silencio, lentamente llega a máximo volumen, manténlo por un momento y rápidamente vuelve a silencio”. Sonic Pi te permite controlar exactamente esta conducta con los envolventes.
Recapitulando lo visto anteriormente, una amplitud de 0 es silencio y una amplitud de 1 es volumen normal.
Ahora, veamos cada una de las partes de las envolventes.
La única parte de la envolvente que es utilizada predeterminadamente es el release, que es el tiempo que le toma al sintetizador para apagar el sonido completamente. Todos los sintetizadores tienen un tiempo de release de 1, lo que significa que tienen una duración de un pulso (el cual por defecto es 1 segundo, si el BPM es 60):
play 70La nota será audible por 1 segundo. ¡Vamos, cronométralo! Esta es la manera abreviada de decir lo mismo que:
play 70, release: 1¡Observa que suenan exactamente igual los últimos dos comandos! Sin embargo, es ahora muy fácil cambiar la duración con tan sólo modificar el valor del release::
play 60, release: 2Podemos hacer que el sintetizador suene por un periodo de tiempo muy corto al poner un valor de release muy pequeño:
play 60, release: 0.2La duración del apagado del sonido es lo que llamamos fase de release y por defecto es una transición lineal. El siguiente diagrama ilustra esta transición:
La línea vertical en la izquierda del diagrama muestra que el sonido comienza con amplitud 0, pero llega a amplitud completa (esto es el ataque, que cubriremos próximamente). Una vez que la amplitud es máxima, se mueve en línea recta hacia abajo hasta llegar a 0, tomando el tiempo que para ello se especificó en release:. * Cuanto más largos son los tiempos de release, más tiempo le toma al sintetizador desvanecerse.*
Puedes, por tanto, cambiar la duración de tu sonido, cambiando el tiempo de release. Prueba a añadir tiempos de release a tu música.
Por defecto, la fase de ataque es 0 para todos los sintetizadores, lo que significa que pasan inmediatamente de amplitud 0 a 1. Ésto le da al sintetizador un sonido inicial percutivo. Sin embargo, podrías desear que el sonido se inicie gradualmente. Esto se logra con el operador attack:. Prueba hacerlo con varios sonidos:
play 60, attack: 2
sleep 3
play 65, attack: 0.5Puedes utilizar varios operadores al mismo tiempo. Por ejemplo para un ataque corto y un release largo, prueba:
play 60, attack: 0.7, release: 4Este ataque corto y largo release queda ilustrado en el siguiente diagrama:
También puedes invertirlo, prueba ahora con un ataque largo y un release corto:
play 60, attack: 4, release: 0.7
Finalmente, puedes poner el ataque y release cortos, para obtener sonidos cortos.
play 60, attack: 0.5, release: 0.5
Adicionalmente a especificar los tiempos de ataque y release, también puedes especificar el tiempo de sustain para controlar la fase de sustain. Este es el tiempo en el cual el sonido está en su máxima amplitud entre las fases de ataque y release.
play 60, attack: 0.3, sustain: 1, release: 1
El sustain es útil para sonidos que quieras resaltar en la mezcla, antes de entrar a la fase opcional de release. Por supuesto, es totalmente válido poner las opciones attack: y release: a 0; de esta forma el sonido aparecerá y desaparecerá de golpe. Sin embargo, ten en cuenta que un release de 0 puede producir clicks en el audio, por lo que se recomienda usar un valor muy pequeño como 0.2.
También puedes especificar el tiempo de decaimiento (decay) para tener un mayor control de tu sonido. Esta fase se encuentra entre el ataque y el sostenimiento (sustain), y simboliza el tiempo que tarda la amplitud en bajar dede el nivel de ataque (attack_level:) hasta el nivel de decay (decay_level:); el decay_level: tiene por defecto el mismo valor que el nivel de sostenimiento (sustain_level:), pero puedes ponerle el valor que tú quieras. Por defecto, la opción decay: vale 0 y los niveles de ataque y sustain valen 1, así que tendrás que cambiar dichos valores para que el tiempo de decaimiento haga efecto:
play 60, attack: 0.1, attack_level: 1, decay: 0.2, sustain_level: 0.4, sustain: 1, release: 0.5
Un último truco… aunque la opción decay_level: está predeterminada a tener el mismo valor que el sustain_level: puedes ser explícit@ y asignarles diferentes valores para tener un control total del envolvente. Esto te permitirá crear envolventes como el siguiente:
play 60, attack: 0.1, attack_level: 1, decay: 0.2, decay_level: 0.3, sustain: 1, sustain_level: 0.4, release: 0.5
También es posible poner el decay_level: más alto que el sustain_level::
play 60, attack: 0.1, attack_level: 0.1, decay: 0.2, decay_level: 1, sustain: 0.5, sustain_level: 0.8, release: 1.5
Para resumir, las envolventes ADSR de Sonic Pi tienen las siguientes fases:
ataque - tiempo que tarda la amplitud en pasar de 0 al attack_level,
decaimiento (decay) - tiempo que tarda la amplitud en pasar del attack_level al decay_level,
sostenimiento (sustain) - tiempo que tarda la amplitud en pasar del decay_level al sustain_level,
release - tiempo que tarda la amplitud en pasar del sustain_level a 0
Es importante recalcar que la duración de un sonido es la sumatoria de los tiempos de todas las fases. Por tanto, el siguiente sonido tendrá una duración de 0.5 + 1 + 2 + 0.5 = 4 pulsos:
play 60, attack: 0.5, attack_level: 1, decay: 1, sustain_level: 0.4, sustain: 2, release: 0.5Ahora ve a jugar con envolventes en tus sonidos…
Otra gran manera de desarrollar tu música es usando sonidos pre-grabados. En la gran tradición del hip-hop, llamamos a estos sonidos pre-grabados sampleos. Así que si tomas un micrófono afuera y grabas el sonido de la lluvia golpeando la tela, ya creaste un sampleo.
Sonic Pi te deja hacer muchas y divertidas cosas con las muestras. No sólo viene con cerca de 90 muestras de dominio libre para que ser utilizados, sino que te deja manipular los tuyos. Veamos…
Tocar con pitidos (beeps) es sólo el principio. Por ejemplo, puedes probar algo realmente divertido, que es lanzar samples pre-grabados. Inténtalo:
sample :ambi_lunar_landSonic Pi incluye muchos samples con los que puedes tocar. Utiliza el comando play para dispararlos. Para tocar varios samples y notas, sólo tienes que escribirlos uno detrás del otro:
play 36
play 48
sample :ambi_lunar_land
sample :ambi_droneSi quieres distribuirlos en el tiempo, usa el comando sleep:
sample :ambi_lunar_land
sleep 1
play 48
sleep 0.5
play 36
sample :ambi_drone
sleep 1
play 36¿Notas que Sonic Pi no espera a finalizar un sonido para comenzar el siguiente? El comando sleep sólo describe la separación de los sonidos disparados. Esto te permite hacer capas de sonidos fácilmente, creando interesantes efectos de capas superpuestas. Más tarde en el tutorial miraremos cómo controlar la *duración *de los sonidos con las envolventes.
Tienes dos formas de ver los samples incluidos en Sonic Pi. Primero, puedes utilizar este sistema de ayuda. Haz click en Samples en el menú vertical a la izquierda, elige una categoria, y verás una lista de sonidos disponibles.
También puedes usar el sistema para auto completar. Sólo tienes que escribir el comienzo de un grupo de samples que empiecen por el mismo nombre; por ejemplo, sample :ambi_. Te saldrá un menú con nombres de samples disponibles, que puedes seleccionar. Prueba con los prefijos de las siguientes categorías:
:ambi_
:bass_
:elec_
:perc_
:guit_
:drum_
:misc_
:bd_
¡Ahora puedes comenzar a mezclar muestras en tus composiciones!
Como ya vimos con los sintetizadores, podemos controlar con facilidad nuestros sonidos con parámetros. Las muestras permiten exactamente el mismo mecanismo de parametrización. Veamos a nuestros viejos conocidos amp: y pan:.
Puedes cambiar la amplitud de los samples igual que la amplitud de los sintetizadores:
sample :ambi_lunar_land, amp: 0.5También podemos utilizar el parámetro pan: para los samples. En el siguiente ejemplo, el amen break suena primero en el oído izquierdo, y a la mitad, pasa al oído derecho:
sample :loop_amen, pan: -1
sleep 0.877
sample :loop_amen, pan: 1Fíjate en que 0.877 es justo la mitad de la duración (en segundos) del sample :loop_amen .
Finalmente, nota que si seteas algunos sintetizadores por defecto con use_synth_defaults (que discutiremos luego), estos serán ignorados por sample.
Ahora que ya podemos tocar una variedad de sintetizadores y samples para crear música, es tiempo de aprender a modificar tanto los sintetizadores como los samples para hacer la música incluso más interesante y única. Primero, exploremos la habilidad de estirar y aplastar los samples.
Los Samples son sonidos pregrabados guardados como números que representan cómo mover los conos de los parlantes para reproducir sonidos. Estos conos se pueden mover hacia dentro y hacia afuera, así que los números sólo deben representar ese movimiento en cada momento dado. Para poder reproducir fielmente un sonido, el sample debe guardar miles de números por segundo! Sonic Pi toma esta lista de números y los alimenta a la velocidad correcta para mover los parlantes de tu ordenador a la velocidad correcta para reproducir el sonido. Sin embargo, también es divertido cambiar la velocidad a la que los números son alimentados al parlante para cambiar el sonido.
Vamos a cambiar uno de los sonidos ambientales. Para la modificación de la velocidad por defecto, se puede agregar ‘rate:’ a la ‘sample’:
sample :ambi_choir, rate: 1Esto lo ejecuta a tiempo normal (1), nada especial. Sin embargo, podemos cambiar ese número por algo más. ¿Qué tal a 0.5?:
sample :ambi_choir, rate: 0.5¡Woah! ¿qué sucedió? Bueno, dos cosas: Primero, el sample se ejecutó en el doble del tiempo; Segundo, sonó una octava más grave. Exploremos todo esto en más detalle.
Un sample que es divertido estirar y comprimir es el Amen Break. A velocidad normal, podemos imaginar ponerlo en una pista de drum ‘n’ bass:
sample :loop_amenSin embargo, cambiando la velocidad podemos cambiar géneros. Intenta con la mitad de la velocidad para algo de “hip hop de la vieja escuela”:
sample :loop_amen, rate: 0.5Si lo aceleramos, entramos al territorio de jungle:
sample :loop_amen, rate: 1.5Vamos a nuestro último truco - veamos qué sucede si utilizamos una velocidad negativa:
sample :loop_amen, rate: -1Ahaa! ¡Se toca al revés! Ahora intenta tocar distintos samples a distintas velocidades. Intenta con velocidades muy rápidas o lentísimas. Observa qué sonidos interesantes puedes crear.
Una manera útil de pensar en samples es comparándolos con resortes. Piensa en la velocidad de ejecución como “estirar” o “comprimir” el resorte. Si tocas a velocidad 2 estás comprimiendo el resorte a la mitad de su tamaño, por tanto le toma la mitad del tiempo en ejecutarse, ya que es más corto. Si ejecutas el sample a la mitad de velocidad, estás en efecto alargando el resorte, por tanto estás doblando su tamaño y el tiempo que le toma ejecutarse. Entre más comprimas (mayor velocidad), más corto se vuelve, entre más estires (menor velocidad), más largo se vuelve.
Comprimir un resorte incrementa su densidad (el número de “vueltas” por cm.) - esto es similar al sample sonando más agudo. Estirar el resorte disminuye su densidad y es similar al sonido siendo más grave.
(Esta sección es para aquellos interesados en los detalles. Eres libre de saltártela…)
Como hemos visto, un sample está representado por una larga lista de números representando donde debe de estar el parlante a través del tiempo. Podemos tomar este listado de números y usarlo para dibujar un gráfico que sería similar a:
Quizás hayas visto imágenes parecidas a esa. Se llaman “forma de onda” de un sampleo. Simplemente es la graficación de números. Típicamente una forma de onda como ésta tendrá 44100 puntos por segundo de datos (esto es debido al teorema de sampleo de Nyquist-Shannon) Así que si el sampleo dura 2 segundos, la forma de onda será representada por 88200 números, alimentándo al altavoz a una velocidad de 44100 puntos por segundo. Claro, podemos también alimentarlos a una velocidad doble, que sería de 88200 puntos por segundo, lo cual tomaría sólo 1 segundo para ser tocado. También podríamos tocarlo a la mitad de velocidad, lo que daría 22050 puntos por segundo tomando 4 segundos de tiempo de ejecución.
La duración del sampleo es afectada por la velocidad de ejecución:
Doblando la velocidad de reproducción se reduce a la mitad el tiempo de ejecución, cortando a la mitad la reproducción, doblamos el tiempo de ejecución, usando una velocidad de ejecución de 1/4, cuadruplicamos el tiempo de reproducción, El uso de una velocidad de reproducción de 1/10, hace que la reproducción dure 10 veces más.
Podemos representar esto con la fórmula:
nuevo_sample_ = (1 / velocidad) * duración_sample Cambiando la velocidad de ejecución se afecta el tono del sampleo. La frecuencia o tono de una forma de onda está determinada por cuán rápido se mueve hacia arriba y hacia abajo. De alguna manera, nuestro cerebro toma los movimientos rápidos de los parlantes a notas agudas, igualmente, torna movimientos lentos de los parlantes en notas graves. Por eso es que puedes ver los parlantes de bajos moverse cuando están dando notas muy bajas, porque en realidad sí se están moviendo adentro/afuera del parlante mucho más lentamente que al producir notas altas.
Si tomas una forma de onda y la comprimes, se moverá más veces por segundo hacia arriba y hacia abajo, lo que producirá un sonido más agudo. Significa que doblando la cantidad de movimientos verticales (oscilaciones) dobla la frecuencia. Así: ejecutar tu sampleo al doble de velocidad, doblará la frecuencia escuchada. Asimismo, reduciendo la velocidad a la mitad, también reduce la frecuencia a la mitad. Otras velocidades afectarán la frecuencia en acordancia.
Es posible modificar la duración y amplitud de un sampleo usando un sobre ADSR. sin embargo, esto funciona algo diferentemente que con los sintetizadores (synths), ya que los sobres para sampleos sólo te permiten reducir la amplitud y duración de un sampleo, pero nunca incrementarlo. El sampleo terminará su ejecución ya sea cuando se acabe o cuando el sobre lo haga, lo que suceda antes. Así que si utilizas un largo ‘release’, ello no extenderá la duración del sampleo.
Volvamos a nuestro amigo, el Amen Break:
sample :loop_amenSin operandos, escuchamos el sampleo completo y amplitud completa. Si quisiéramos aparecerlo dentro de 1 segundo, podemos utilizar el parámetro attack::
sample :loop_amen, attack: 1Para un desaparecimiento más corto, elegiríamos un valor de ataque menor:
sample :loop_amen, attack: 0.3Donde el sobre ADSR difiera en su conducta con el de un sintetizador es en el valor del sustain. En el sobre de un sintetizador, el sustain está predeterminado a 0 si no lo cambias manualmente. Con sampleos, el valor predeterminado de sustain está en automágico - el tiempo que resta para terminar el resto del sampleo. A ello se debe que podamos escuchar el sampleo completo cuando no pasamos parámetros. Si los valores de ataque, decaimiento,sustain y release fueran 0, nunca escucharíamos el sampleo. Por eso Sonic Pi calcula qué tan largo es el sampleo, deduce su ataque, decaimiento y tiempo de release, para utilizar esa sumatoria como tiempo de sustain. Si los valores de ataque, decaimiento y release son mayores al sampleo, el sustain se vuelve 0, simplemente.
Para explorar esto, consideremos nuestra pista Amen break en detalle. Si le preguntamos a Sonic Pi cuán largo es el sampleo:
print sample_duration :loop_amenImprimirá 1.753310657596372 que es el tamaño del sampleo en segundos. Consideremos redondearlo a 1.75 por conveniencia. Ahora, si seteamos el release a 0.75, algo sorpresivo pasará:
sample :loop_amen, release: 0.75Ejecutará el primer segundo del sampleo a amplitud completa antes de desvanecerse por un periodo de 0.75 segundos. Esto es el auto sustain en acción. Predeterminado, el release siempre trabaja al final del sampleo. si tu sampleo fuera 10.75 segundos de largo, ejecutaría los primeros 10 segundos a completa amplitud antes de comenzar a desvanecerse por los 0.75 segundos finales.
Recuerda: por defecto, release: se desvanece al final de un sample.
Podemos utilizar tanto el attack: como el release: juntos con el auto sustain para aparecer y desvanecer en la duración del sampleo:
sample :loop_amen, attack: 0.75, release: 0.75Como la duración total del sampleo + attack + release suman 1.5s, el sustain queda automáticamente en 0.25s. Esto nos permite aparecer y desvanecer el sampleo con facilidad.
Podemos fácilmente volver a los parámetros normales de nuestro ADSR de sintetizador al setear manualmente el sustain: a un valor como 0:
sample :loop_amen, sustain: 0, release: 0.75Ahora bien, nuestro sampleo suena por 0.75 en total. Los parámetros pre- determinados para ‘attack: y decay:` son 0, el sampleo salta directamente a full amplitud por 0s y después baja a 0 de amplitud por un periodo de release de 0.75s
Podemos utilizar esta conducta a buen efecto para sampleos más largos que requieran los acortemos y percusivos. Considera el siguiente sampleo: :drum_cymbal_open:
sample :drum_cymbal_openPuedes escuchar el sonido del platillo por un periodo de tiempo. Sin embargo, podemos usar el sobre para hacerlo más percusivo:
sample :drum_cymbal_open, attack: 0.01, sustain: 0, release: 0.1Puedes emular el golpeo del platillo y después apagarlo, al incrementar el periodo de sustain:
sample :drum_cymbal_open, attack: 0.01, sustain: 0.3, release: 0.1Ahora ve y diviértete poniendo sobres en los sampleos. Intenta cambiar la velocidad, también para unos resultados realmente interesantes.
Esta sección concluirá nuestra exploración del ejecuta sampleos de Sonic Pi. Hagamos un pequeño resumen; Hasta ahora hemos mirado cómo podemos disparar sampleos:
sample :loop_amenDespués miramos cómo cambiar la velocidad de los sampleos tales como ejecutarlos a media velocidad:
sample :loop_amen, rate: 0.5Después miramos como podíamos aparecer un pequeño sampleo (haámoslo a media velocidad):
sample :loop_amen, rate: 0.5, attack: 1También miramos como podíamos usar el comienzo de un sampleo percusivamente al darle a sustain: un valor explícito y setear ambos el ataque y el release con valores cortos:
sample :loop_amen, rate: 2, attack: 0.01, sustain: 0, release: 0.35Sin embargo, ¿No sería mejor si no tuviésemos que comenzar por el principio ó terminar por el fin..siempre?
Es posible elegir un punto de inicio arbitrario en el sampleo con un valor entre 0 y 1, donde 0 es el punto de comienzo, 1 es el punto de final y 0.5 es la mitad del sampleo. Intentemos ejecutar únicamente la última mitad del sampleo de amen break:
sample :loop_amen, start: 0.5¿Qué tal escuchar el último cuarto del sample?:
sample :loop_amen, start: 0.75Igualmente, es posible escoger un punto de termino arbitrario en el sample, con un valor entre 0 y 1. Vamos a terminar el amen break a la mitad:
sample :loop_amen, finish: 0.5Por supuesto que podemos combinar dos para tocar segmentos del archivo de audio arbitrariamente. ¿Qué tal una pequeña sección en el medio?
sample :loop_amen, start: 0.4, finish: 0.6¿Qué pasa si elegimos comenzar en una posición después del final?
sample :loop_amen, start: 0.6, finish: 0.4¡Cool! ¡Se toca al revés!
Podemos combinar esta nueva herramienta para tocar segmentos arbitrarios de audio con nuestro amigo rate:. Por ejemplo, podemos tocar una pequeña sección al medio de amen break muy lentamente:
sample :loop_amen, start: 0.5, finish: 0.7, rate: 0.2Finalmente podemos combinar todo esto con el sobre ADSR para producir resultados interesantes:
sample :loop_amen, start: 0.5, finish: 0.8, rate: -0.2, attack: 0.3, release: 1Ahora vete y juega con sampleos y todas estas divertidas herramientas…
Mientras los samples incluidos te ayudan a iniciar rápido, quizá quieras experimentar con otros sonidos grabados en tu música. Sonic Pi lo soporta completamente. Primero, revisemos brevemente la portabilidad de tu pieza musical.
Cuando compones una pieza solamente con sintetizadores y samples incluidos, el código es todo lo que necesitas para reproducir tu música. Piensa en esto por un momento - es maravilloso! Un texto sencillo que puedes enviar por email o pegar en un Gist representa todo lo que necesitas para reproducir tus sonidos. Eso hace que sea realmente fácil de compartir con tus amigos que sólo necesitan tu código.
Por otra parte, si usas tus samples pregrabados, pierdes esta portabilidad. Esto es debido a que reproducir tu música, otras personas no solo necesitan tu código, necesitan tus samples también. Esto limita la habilidad para otros de manipular, combinar y experimentar con tu trabajo. Por supuesto, esto no debe detenerte para usar tus propios samples, es solamente algo a considerar.
¿Cómo reproduces cualquier archivo WAV, AIFF o FLAC en tu computadora? Todo lo que necesitas es indicar la ubicación del archivo en sample:
# Raspberry Pi, Mac, Linux
sample "/Users/sam/Desktop/my-sound.wav"
# Windows
sample "C:/Users/sam/Desktop/my-sound.wav"Sonic Pi cargará y reproducirá el sample. También puedes indicar todos los parámetros estándar que acostumbras, indicando a sample:
# Raspberry Pi, Mac, Linux
sample "/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3
# Windows
sample "C:/Users/sam/Desktop/my-sound.wav", rate: 0.5, amp: 0.3Nota: esta sección del tutorial cubre un tema avanzado con directorios grandes de tus propios samples. Este puede ser el caso si has descargado o comprado tus paquetes de samples y deseas usarlos en Sonic Pi.
Siéntete libre de leer esto si estás feliz usando los samples incluídos.
Cuando trabajas con carpetas grandes de samples externos puede ser difícil tener que escribir toda la ruta cada vez que quieras usar un sample.
Por ejemplo, si tienes la siguiente carpeta en tu máquina:
/path/to/my/samples/Cuando vemos dentro de la carpeta, encontramos los siguientes samples:
100_A#_melody1.wav
100_A#_melody2.wav
100_A#_melody3.wav
120_A#_melody4.wav
120_Bb_guit1.wav
120_Bb_piano1.wav
Típicamente, para reproducir un sample de piano, podemos usar la ruta completa:
sample "/path/to/my/samples/120_Bb_piano1.wav"Si queremos reproducir un sample de guitarra podemos usar su ruta completa también:
sample "/path/to/my/samples/120_Bb_guit.wav"Sin embargo, cada uno de estos llamados a sample requieren que sepamos los nombres de los samples en nuestro directorio. ¿Que tal si solo quisiéramos escuchar cada sample, uno tras otro, rápidamente?
Si queremos reproducir el primer sample en un directorio, necesitamos indicar el nombre del directorio en sample y el índice 0 de la siguiente manera:
sample "/path/to/my/samples/", 0Podemos incluso hacer un acceso directo a la ruta de nuestro directorio usando una variable:
samps = "/path/to/my/samples/"
sample samps, 0Ahora, si queremos reproducir un segundo sample en nuestro directorio, sólo necesitamos añadir 1 a nuestro índice:
samps = "/path/to/my/samples/"
sample samps, 1Date cuenta de que ya no necesitamos saber los nombres de los samples en el directorio - solamente debemos conocer el directorio (o tener una abreviatura para él). Si requerimos un indice que es mas grande que el numero de samples, simplemente retornamos al principio del directorio como si fuera un anillo. De cualquier manera, sin importar el número de índice que usemos, esta garantizado que tendremos un sample del directorio.
Usualmente con indexarlos es suficiente, pero algunas veces necesitamos algo mas poderoso para organizar nuestros samples. Afortunadamente muchos paquetes de samples añaden información valiosa en los nombres de los archivos. Ahora miremos de nuevo los nombres de los samples en nuestro directorio:
100_A#_melody1.wav
100_A#_melody2.wav
100_A#_melody3.wav
120_A#_melody4.wav
120_Bb_guit1.wav
120_Bb_piano1.wav
Date cuenta de que en estos nombres de archivo tenemos bastante información. En primer lugar tenemos el BPM del sample (número de pulsaciones por minuto) al comienzo. Por lo tanto, el sample del piano está a 120 BPM y nuestras primeras tres melodías están a 100 BPM. Además, nuestros nombres de los samples contienen la clave musical. Por tanto, el sample de la guitarra está en Bb (si bemol) y las melodías están en A# (la sostenido). Esta información es muy útil para mezclar estos samples con el resto del código. Por ejemplo, sabemos que solamente podemos usar el sample del piano con código que está a 120 BPM y en la clave de Bb.
Podemos usar como convención esta nomenclatura de nuestros conjuntos de samples en el código para ayudarnos a filtrar los que queremos. Por ejemplo, si trabajamos a 120 BPM, podemos filtrar a todos los ejemplos que contienen la cadena " 120 " con lo siguiente:
samps = "/path/to/my/samples/"
sample samps, "120"Ésto ejecutará el primer sample. Si queremos el segundo sample sólo necesitamos usar el índice:
samps = "/path/to/my/samples/"
sample samps, "120", 1Incluso podemos usar varios filtros al mismo tiempo. Por ejemplo, si queremos un sample cuyo nombre de archivo contenga las subcadenas “120” y “A #”, lo encontraremos fácilmente con el siguiente código:
samps = "/path/to/my/samples/"
sample samps, "120", "A#"Por último, podemos añadir las opciones habituales al sample:
samps = "/path/to/my/samples/"
sample samps, "120", "Bb", 1, lpf: 70, amp: 2El sistema de pre-arg de filtro del sample entiende dos tipos de información: fuentes y filtros. Las fuentes son información utilizada para crear la lista de candidatos potenciales. Una fuente puede tomar dos formas:
“/path/to/samples” - una cadena que representa una ruta de acceso válida a un directorio “/path/to/samples/foo.wav” - Una cadena que representa una ruta válida a un sample
El ‘sample’ fn primero coge todas las fuentes y crear una lista con todos los candidatos. Esta lista se construye agregando primero todas las rutas válidas y añadiendo, luego, todos los ficheros .flac, .aif, .aiff, .wav, .wave contenidos en los directorios.
Por ejemplo, echemos un vistazo al siguiente código:
samps = "/path/to/my/samples/"
samps2 = "/path/to/my/samples2/"
path = "/path/to/my/samples3/foo.wav"
sample samps, samps2, path, 0Aquí, combinamos el contenido de los samples dentro de dos directorios y añadiendo un sample específico. Si "/path/to/my/samples/" contiene 3 samples y "/path/to/my/samples2/" contiene 12, tenemos 16 samples potenciales para indexar y filtrar (3 + 12 + 1).
Por defecto, sólo los samples de un directorio se agrupan en una lista de candidatos. Es posible que tenga una serie de subcarpetas de samples en la que quieras buscar y filtrar. Por lo tanto, puedes realizar una búsqueda recursiva de todas los samples dentro de todas las subcarpetas de una carpeta determinada añadiendo ** al final de la ruta:
samps = "/path/to/nested/samples/**"
sample samps, 0Ten cuidado ya que la búsqueda en un conjunto muy grande de carpetas puede tomar mucho tiempo. Sin embargo, el contenido de todas las fuentes de las carpetas se almacenan en el caché, por lo que el retraso sólo se producirá la primera vez.
Por último, ten en cuenta que las fuentes deben ir primero. Si no se da ninguna fuente, entonces el conjunto de samples incorporados se seleccionará de la lista predeterminada de candidatos con los que trabajar.
Una vez que tienes una lista de candidatos deberías usar los siguientes tipos de filtros para reducir aún más la selección:
`` Foo ‘Las cadenas filtrarán la ocurrencia de la subcadena dentro del nombre de archivo (menos la ruta del directorio y la extensión).
/fo[oO]/ Regular Expresssions filtrará aquellos archivos cuyo nombre sea más parecido al del archivo especificado (en el nombre de archivo no se incluye su ruta ni su extensión de archivo).
:foo - Keywords filtrará aquellos candidatos donde la palabra clave coincida directamente con el nombre de archivo (salvo la ruta y la extensión).
lambda{|a| … } - Los procesos con un argumento serán tratados como un filtro candidato o como una función generadora. Se pasará la lista de candidatos actuales, y deberá devolver una lista nueva de candidatos (es decir, una lista de rutas válidas a archivos de samples).
1` - Los números seleccionarán el candidato cuyo índice coincida con dicho número (dando la vuelta como una estructura de anillo si hace falta).
Por ejemplo, podemos filtrar sobre todos las muestras en un directorio que contengan el string "foo" y ejecutar la primera muestra correspondiente a la mitad de su velocidad:
sample "/path/to/samples", "foo", rate: 0.5Mira la sección de ayuda para sample donde encontrarás muchos ejemplos de uso detallados. Ten en cuenta que debes respetar el orden de los filtros.
Finalmente, puedes usar listas dentro de una fuente o filtro. La lista será aplanada automáticamente, y sus contenidos serán tratados como fuentes y filtros normales y corrientes. Por tanto, las siguientes llamadas a sample son equivalentes sintácticamente:
sample "/path/to/dir", "100", "C#"
sample ["/path/to/dir", "100", "C#"]
sample "/path/to/dir", ["100", "C#"]
sample ["/path/to/dir", ["100", ["C#"]]]Ésta es una sección avanzada pensada para gente que necesite manipular y usar paquetes de samples de forma eficiente. No te preocupes si no entiendes si esta sección. Es probable que no necesites ninguna de estas opciones ahora mismo. Cuando llegue el momento. verás si te hacen falta estas herramientas; siempre puedes volver y leer esta ayuda de nuevo cuando empieces a trabajar con directorios de samples muy grandes.
Una manera de añadir interés a tu música es usando números aleatorios. Sonic Pi tiene gran funcionalidad añadiendo aleatoriedad a la música, pero antes de comenzar, debemos aprender una verdad chocante: en Sonic Pi no existe aleatoriedad real. ¿Qué significa eso?
Una función realmente útil es rrand la cual te da un valor aleatorio entre dos números - un min y un max. (rrand es la abreviatura para ranged random). Intentemos tocar una nota al azar:
play rrand(50, 95)¡Ooh, tocó una nota al azar! Tocó la nota 83.7527. Una nota entre 50 y 95 Woah, espera, predije el número correcto que obtuviste? ¡Algo raro sucede! Intenta con el código de nuevo. ¿qué? Otra vez 83.7527 ? ¡Eso no es aleatorio!
La respuesta es que no es realmente aleatorio, es pseudo-aleatorio. Sonic Pi te dará números como al azar en una manera repetitiva, lo cual es muy útil para asegurar que la música que creas en tú máquina suene idéntica en cualquier otra máquina - aunque utilices números al azar en tú composición.
Claro que en una pieza musical donde quieras colocar notas al “azar” y siempre eliga 83.7527 no sería ni aleatorio ni interesante. Sin embargo, no es así. Intenta lo siguiente:
loop do
play rrand(50, 95)
sleep 0.5
end ¡Sí! Finalmente suena aleatorio. Dentro de una misma corrida las subsecuentes llamadas a funciones aleatorias dan valores..aleatorios. Sin embargo, la próxima corrida volverá a dar la misma secuencia de valores “aleatorios” y sonar exactamente igual. Es como si Sonic Pi volvió en el tiempo al mismo punto cuando se corrió run la primera vez. ¡Es el Groundhog Day de la síntesis musical!
Una buena ilustración de aleatoriedad en acción es el ejemplo haunted bells que buclee el sampleo de :perc_bell con velocidad de Aleatoriedad y tiempo de pausa entre los sonidos:
loop do
sample :perc_bell, rate: (rrand 0.125, 1.5)
sleep rrand(0.2, 2)
endOtro buen ejemplo de aleatoriedad es modificar el momento de corte de un sintetizador, en forma aleatoria. Un gran synth en el que hacerlo es el emulador :tb303
use_synth :tb303
loop do
play 50, release: 0.1, cutoff: rrand(60, 120)
sleep 0.125
end¿Entonces qué, no te gusta la particular secuencia de números al azar que provee Sonic Pi? Bueno, es totalmente posible elegir un punto de comienzo via use_random_seed. Predeterminado está a 0, así que: ¡elige una semilla diferente para una aleatoriedad diferente!
Considera lo siguiente:
5.times do
play rrand(50, 100)
sleep 0.5
endCada vez que corras ese código escucharás la misma secuencia de 5 notas. Para cambiar la secuencia, simplemente cambia el valor de seed_:
use_random_seed 40
5.times do
play rrand(50, 100)
sleep 0.5
endEsto producirá una diferente secuencia de 5 notas. Al cambiar el valor de seed y escuchar los resultados, puedes encontrar algo que te guste y cuando lo compartas con otros, escucharán exactamente lo mismo.
Veamos otras útiles funciones de aleatoriedad.
Una cuestión común es elegir un ítem desde una lista de ítems conocidos Por ejemplo, quiero tocar una nota de entre las siguientes: 60, 65 or 72. Puedo lograr eso con choose pues me deja elegir un ítem de esa lista. Primero necesito confeccionar mi listado entre paréntesis cuadrados y separándolos por comas: [60, 65, 72]. Después sólo necesito pasarlos por choose:
choose([60, 65, 72])Escuchemos como suena:
loop do
play choose([60, 65, 72])
sleep 1
endYa hemos visto la función rrand, pero adentrémonos más en ella. Nos proporciona un número aleatorio entre dos valores. Eso significa que nunca nos dará los números extremos del rango, sólo entre ellos. Ese número será un ‘flotante’, lo que significa que no es un número entero, sino una fracción de número. He aquí ejemplos de flotantes: rrand(20, 110):
87.5054931640625 86.05255126953125 61.77825927734375
Ocasionalmente querrás un número entero aleatorio, no un flotante. Es entonces que rrand_i viene al rescate. Funcional similarmente a rrand excepto que incluye los valores mínimo y máximo como potenciales aleatorios (lo que significa que es inclusiva y no excluyente de los valores extremos del rango). Ejemplos de números con rrand_i(20, 110) son:
88 86 62
Esta función te regresará un número aleatorio flotante incluyendo los valores 0 y el máximo especificado. Predeterminado está el rango entre 0 y 1. Por ello es útil para elegir valores de amp: aleatorios:
loop do
play 60, amp: rand
sleep 0.25
endDe maneara similar a rrand_i y rrand, rand_i nos dará un número leatorio ENTERO entre 0 y el máximo especificado.
Alguna vez querrás emular el tiro de un dado. Para ello tenemos un caso especial de rrand_i donde el valor inferior será siempre 1. El uso de dice requiere que especifiques el número de lados del dado. Un dado estándard tiene 6 lados, así dice(6) actuará similarmente, dando valores de1, 2, 3, 4, 5, or 6. Sin embargo, como en los juegos de role-play encontrarás necesidad de un dado de 4, 12, 20 o inclusive de 120 caras..
Finalmente cuando quieras emular tirar el máximo puntaje con un dado, como 6 en un dado estándard one_in te dará eso con una posibilidad de uno en número de lados del dado. Por lo tanto, one_in(6) nos dará verdad con una probabilidad de 1 en 6 o falso. Verdadero y falso son valores muy útiles para if el cual cubriremos en la siguiente sección de este tutorial.
¡Ahora ve a jugar con códigos y algo de aleatoriedad!
Ahora que has aprendido lo básico de crear sonidos con play y sample y crear ritmos y melodías simples con sleep en medio de los sonidos, podrías preguntarte ¿Qué es lo que codificar puede ofrecerte?
Bueno, estás a punto de ser sorprendido, porque resulta que herramientas básicas de estructuras de programación como bules, condicionales, funciones e hilos, te dan grandes posibilidades de expresión musical.
Concentrémonos en la base…
Una estructura que verás a menudo en Sonic Pi es el bloque. Los Bloques nos permiten hacer cosas útiles con largas sábanas de código. Por ejemplo, con parámetros de synth y sample podíamos cambiar cosas en una sóla línea. sin embargo, algunas veces queremos hacer algo significativo para un número de líneas de código. Por ejemplo buclear, añadir reverberación, pero sólo correrlo 1 de cada 5 veces. Considera el siguiente código:
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62Para hacer algo con un manojo de códifo, necesitamos decirle a Sonic Pi dónde comienza el bloque de código y dónde termina. Usamos para el comienzo do y para el final end . Por ejemplo:
do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
endSin embargo, ese código está incompleto, porque no le hemos dicho a Sonic Pi lo que queremos hacer con ese bloque do/end (intenta y te dará error). Eso se lo decimos a Sonic Pi al escribir algunos códigos especiales antes del do. Veremos un estos códigos especiales más adelante en este tutorial Por ahora es importante conocer que envolver tu código entre do y end le dice a Sonic Pi que deseas hacer algo especial con ese pedazo de código.
Hasta ahora hemos invertido tiempo en los diferentes sonidos que puedes crear con bloques de play y sample. También hemos aprendido a disparar estos sonidos a través de sleep.
Como probablemente ya notaste, hay mucha diversión a ser obtenida con estos bloques básicos de construcción. Sin embargo, una dimensión totalmente diferente de diversión se abre cuando comienzas a usar el poder de codificar para estructurar tu música y composiciones. En los próximos segmentos exploraremos algunas de estas poderosas herramientas. Primero están las iteraciones y bucles.
¿Has escrito código que te gustaría se repita unas cuantas veces? Por ejemplo, algo así:
play 50
sleep 0.5
sample :elec_blup
sleep 0.5
play 62
sleep 0.25¿qué tal si quieeres repetirlo 3 veces? Bueno, podrías hacer algo simple y copiarlo 3 veces:
play 50
sleep 0.5
sample :elec_blup
sleep 0.5
play 62
sleep 0.25
play 50
sleep 0.5
sample :elec_blup
sleep 0.5
play 62
sleep 0.25
play 50
sleep 0.5
sample :elec_blup
sleep 0.5
play 62
sleep 0.25¡Eso fué bastante código! ¿qué pasa si quieres cambiar el sample a :elec_plip? Tendrías que buscar todos los lugares con el original :elec_blup y cambiarlo. Más importantemente, ¿qué si quisieras repetir l apieza original 1000 veces? Eso tomaría muchas líneas de código y lugares a los que ir a alterar si quisieses cambiar algo.
De hecho, repetir código debería ser tan fácil como decirle haz esto tres veces. Bueno, así es, casi..Recuerda nuestro viejo amigo el bloque de código, lo podemos usar para marcar el comienzo y final de código que querramos repetir tres veces. Después usamos el código especial 3.times. Así, en vez de escribir do this three times, escribimos 3.times do - ¿sencillo, no? Sólo recuerda escribir end al final del código que quieras repetir:
3.times do
play 50
sleep 0.5
sample :elec_blup
sleep 0.5
play 62
sleep 0.25
end¿Eso fué mucho más elegante que cortar y pegar! Así crearemos muchas estructuras repetitivas_:
4.times do
play 50
sleep 0.5
end
8.times do
play 55, release: 0.2
sleep 0.25
end
4.times do
play 50
sleep 0.5
endPodemos insertar iteraciones dentro de iteraciones para crear patrones interesantes. Por ejemplo:
4.times do
sample :drum_heavy_kick
2.times do
sample :elec_blip2, rate: 2
sleep 0.25
end
sample :elec_snare
4.times do
sample :drum_tom_mid_soft
sleep 0.125
end
endSi deseas que algo se repita muchas veces, te puedes encontrar usando números realmente grandes como 1000.times do. En este caso es mejor pedirle a Sonic Pi que repita al infinito (hasta que aprietes el botón de parar). Bucleemos el amen break infinitamente:
loop do
sample :loop_amen
sleep sample_duration :loop_amen
endLo importante de saber acerca de los blucles (loops) es que actúan como hoyos negros para el código. Una vez que se entra ahí, sólo se sale con el botón de parar (stop). Esto significa que si tienes código después del loop, nunca lo escucharás. Por ejemplo, el platillo después de este bucle nunca se ejecutará:
loop do
play 50
sleep 1
end
sample :drum_cymbal_open¡Ahora ve a estructurar tus códigos con iteración y bucles!
Algo común que seguramente querrás hacer es tocar más que notas al azar sino también tomar decisiones al azar y, dependiendo de cómo salga, correr más código u otro código. Por ejemplo, el querer tocar al azar una batería o platillo. Esto lo podemos hacer con if .
Tiremos una moneda: si sale cara, que suene una batería, si sale cruz, que sea un platillo. Fácil. Podemos imitar el tiro de una moneda con la función one_in (introducida en la sección de aleatoriedad) especificando una probabilidad de 1 en 2 one_in(2). Entonces podemos utilizar el resultado para decidir entre dos piezas de código, el de batería o el de platillos:
loop do
if one_in(2)
sample :drum_heavy_kick
else
sample :drum_cymbal_closed
end
sleep 0.5
endDebes notar que los if están compuestos de tres partes:
La pregunta a hacer La primera elección de código a correr (si la respuesta es ‘si’) La segunda elección de código a correr (si la respuesta es ‘no’)
Típico de lenguajes de programación, la noción de ‘sí’ está representada por el término true y la noción de ‘no’, por false. Así que debemos encontrar una pregunta que nos dé una respuesta true ofalse que es exactamente lo que hace one_in .
¿notas que la primera opción está envuelta entre el if y el else y que la segunda opción está envuelta entre el else y el end?. Igual que con los bloques do/end puedes poner múltiples líneas de código en cualquiera de esos lugares. Por ejemplo:
loop do
if one_in(2)
sample :drum_heavy_kick
sleep 0.5
else
sample :drum_cymbal_closed
sleep 0.25
end
endEsta vez estaremos pausando por un tiempo distinto dependiendo de cuál elección hagamos.
Algunas veces querrás ejecutar sólo una línea de código. Esto es posible al colocar if y después la pregunta al final. Por ejemplo:
use_synth :dsaw
loop do
play 50, amp: 0.3, release: 2
play 53, amp: 0.3, release: 2 if one_in(2)
play 57, amp: 0.3, release: 2 if one_in(3)
play 60, amp: 0.3, release: 2 if one_in(4)
sleep 1.5
endEso tocará acordes de diferentes números con una probabilidad diferente para cada nota .
Así que hiciste una gran línea de bajo y un gran pulso. ¿cómo los tocas al mismo tiempo? Una manera de hacerlo es coserlos juntos manualmente - toca bajo, después un poco de batería y así… Sin embargo, cada vez se vuelve más complicado mantener el timing, especialmente Si’coses’ más y más elementos.
¿qué tal si Sonic Pi pudiese coser todo automáticamente para tí? Bueno, puede y lo hace con algo especial llamado thread.
Para mantener este ejemplo sencillo, vas a tener que imaginar que es un gran pulso y bajo:
loop do
sample :drum_heavy_kick
sleep 1
end
loop do
use_synth :fm
play 40, release: 0.2
sleep 0.5
endComo vimos anteriormente, bucles son como ‘hoyos negros’ para el programa, una vez entras a uno, sólo puedes salir de él con el botón ‘stop’. Así que para tocar ambos bucles al mismo tiempo, debemos indicarle a Sonic Pi que queremos comenzar algo al mismo tiempo que el resto del código, aquí es cuando los hilos vienen al rescate.
in_thread do
loop do
sample :drum_heavy_kick
sleep 1
end
end
loop do
use_synth :fm
play 40, release: 0.2
sleep 0.5
endAl envolver el primer bucle de bloque do/end con in_thread le decimos a Sonic Pi que corra los contenidos del bloque do/end exactamente al mismo tiempo que el siguiente bloque do/end (que es nuestro segundo bucle) ¿Inténtalo y escucharás ambos, el bajo y la batería conectados!
Ahora, si quisiésemos añadir un sintetizador, haríamos algo así:
in_thread do
loop do
sample :drum_heavy_kick
sleep 1
end
end
loop do
use_synth :fm
play 40, release: 0.2
sleep 0.5
end
loop do
use_synth :zawa
play 52, release: 2.5, phase: 2, amp: 0.5
sleep 2
endAhora volvemos a tener el mismo problema que antes, ya que los primeros dos bucles se tocan al mismo tiempo, gracias a in_thread. Sin embargo, el tercer bucle nunca se alcanza. Por lo tanto, necesitamos otro hilo:
in_thread do
loop do
sample :drum_heavy_kick
sleep 1
end
end
in_thread do
loop do
use_synth :fm
play 40, release: 0.2
sleep 0.5
end
end
loop do
use_synth :zawa
play 52, release: 2.5, phase: 2, amp: 0.5
sleep 2
endPuede sorprenderte que cuando aprietas el botón de Correr (Run), de hecho estás creando un nuevo hilo para que corra el código. Esta es la razón por la que al apretar el botón múltiples veces, suenan las capas de sonido una encima de la otra, ya que las corridas son de hecho hilos cosidos automáticamente para sonar.
En cuanto más aprendas Sonic Pi, apreciarás que los hilos son los bloques de construcción más importantes para tú música. Uno de los trabajos más importantes que realiza es aislar la noción de seteos actuales respecto a otros hilos. ¿qué significa eso? Bien, cuando cambias sintetizadores por medio de use_synth realmente estás cambiando el sintetizdor en el hilo actual, ya que ningún otro hilo cambiarás su sintetizador. Veamos esto en acción:
play 50
sleep 1
in_thread do
use_synth :tb303
play 50
end
sleep 1
play 50¿Notaste que el sonido de en medio era diferente a los otros? el use_synth solamente afectó el hilo en el que se encontraba, no así el hilo externo principal.
Cuando creas un nuevo hilo con in_thread, este automáticamente hereda la configuración del hilo actual. Veamos:
use_synth :tb303
play 50
sleep 1
in_thread do
play 55
end¿Notaste que la segunda nota es tocada por el sintetizador :tb303 aunque era de un hilo separado? Cualquier seteo modificado con las funciones use_* se comportará de igual manera.
Cuando se crean hilos, ellos heredan todos los seteos de su padre, pero no los comparten a su vez.
Por último, podemos darles nombre a los hilos:
in_thread(name: :bass) do
loop do
use_synth :prophet
play chord(:e2, :m7).choose, release: 0.6
sleep 0.5
end
end
in_thread(name: :drums) do
loop do
sample :elec_snare
sleep 1
end
endMira el panel de bitácora cuando corras este código. ¿ves que reporta el nombre del hilo?
[Run 36, Time 4.0, Thread :bass]
|- synth :prophet, {release: 0.6, note: 47}Una cosa más al respecto de nombrar hilos es que sólo un hilo con su nombre puede estar corriendo a la vez. Exploremos esto, considerando el código:
in_thread do
loop do
sample :loop_amen
sleep sample_duration :loop_amen
end
endPega eso en un buffer y córrelo. Presiona Correr un par de veces. Escucha la cacofonía de los múltiples amen breaks bucleando desincronizadamente. Ok, ya puedes pararlo.
Esta es la conducta que hemos visto innumerables veces - si presionas el botón Correr, capas de sonidos suenan encima de otras. Así que si tienes un loop y presionas el botón Correr tres veces, obtendrás tres capas de bucles sonando simultáneamente.
sin embargo, con hilos nombrados, es diferente:
in_thread(name: :amen) do
loop do
sample :loop_amen
sleep sample_duration :loop_amen
end
endIntenta presionando el botón Correr múltiples veces con este código. Sólo escucharás un bucle del amen break. También verás lo siguiente en la bitácora:
==> Omitiendo creación de hilo: ya existe un hilo con el nombre :amen.Sonic Pi te está diciendo que un hilo con el nombre :amen ya existe, así que no creará otro.
Esta conducta puede no aparentar utilidad para tí - pero verás que la tiene cuando comencemos a hacer Código-vivo…
Cuando comiences a escribir mucho código, desearás encontrar una manera de organizar y estructurar todo para hacerlo más entendible. Las funciones permiten hacer exactamente eso, permitiéndonos darle nombre a muchas partes de nuestro código. Veamos:
define :foo do
play 50
sleep 1
play 55
sleep 2
endAquí definimos una nueva función llamada foo. Lo hacemos con nuestro viejo amigo el bloque de do/end y la palabra mágica define seguidos del nombre que queremos darle a nuestra función. No necesitábamos llamarla foo, podríamos haberla llamado cualquier cosa que quisiésemos, tales como bar, baz o idealmente algo significativo para tí como main_section o lead_riff.
Recuerda anteponer dos puntos : al nombre de la función que defines.
Una vez hemos definido nuestra función, podemos llamarla simplemente escribiendo su nombre:
define :foo do
play 50
sleep 1
play 55
sleep 0.5
end
foo
sleep 1
2.times do
foo
endIncluso podemos usar foo dentro de bloques de iteración o cualquier lugar donde hayamos escrito play o sample. Esto nos da una fantástica manera de expresar y crear nuevas palabras significativas a usar en nuestras composiciones.
Hasta ahora, cada vez que presionamos el botón de Ejecutar, Sonic Pi ha comenzado de cero. Sólo conoce lo que está en el buffer actual. No puedes referenciar código en otro buffer o hilo. sin embargo, las funciones cambian eso. Cuando defines una función, Sonic Pi recuerda. Probemos borrando todo el código en tu buffer y reemplazandolo por:
fooPresiona el botón de Ejecutar y escucha. ¿Dónde se fue el código?¿cómo supo Sonic Pi qué tocar? Sonic Pi recordó tu función, inclusive cuando la borraste del buffer. Esta conducta sólo funciona con las funciones creadas con define (y defonce).
Quizás te interese saber que al igual que podías pasar valores mínimos y máximos con rrand, también puedes enseñar a tus funciones a aceptar argumentos. Miremos:
define :my_player do |n|
play n
end
my_player 80
sleep 0.5
my_player 90Esto no es tan excitante, pero ilustra el punto. Creamos nuestra propia versión de play llamada my_player y la cual está parametrizada.
Los parámetros deben ir después del do y define en el bloque do/end, rodeado de postes verticales | y separados por comas ,. Puedes usar cualquier palabra para los nombres de los parámetros.
Lo mágico sucede dentro del bloque do/end del define . Puedes usar nombres de parámetros como si fueran valores reales. En este ejemplo estoy tocando la nota n. Puedes considerar los parámetros como una especie de promesa de que cuando el código se ejecute, ellos serán reemplazados por los valores. Esto lo haces al pasar un parámetro a la función, cuando la llamas. Yo lo hago con my_player 80 para tocar la nota 80. Dentro de la definición de la función n se reemplaza con 80, así play n se convierte en play 80. Cuando la llamo otra vez con my_player 90, n es reemplazada por 90, así que play n se convierte en play 90.
Veamos un ejemplo más interesante:
define :chord_player do |root, repeats|
repeats.times do
play chord(root, :minor), release: 0.3
sleep 0.5
end
end
chord_player :e3, 2
sleep 0.5
chord_player :a3, 3
chord_player :g3, 4
sleep 0.5
chord_player :e3, 3Aquí usé repeats como si fuera un número para la línea de repeats.times do. También usé root como si fuera un nombre de nota en mi llamada a play.
¡Nota cómo podemos utilizar algo muy expresivo y fácil de leer sólo con mover mucho de nuestra lógica en el código!
Algo útil para hacer con tú código es crear nombres para las cosas. Sonic Pi hace esto muy fácil, escribes el nombre que deseas utilizar, un símbolo de (=), después lo que quieres recordar:
sample_name = :loop_amenAquí hemos ‘recordado’ el símbolo :loop_amen en la variable sample_name. Ahora podemos usar sample_name en cualquier lugar donde pudiésemos usar :loop_amen. Por ejemplo:
sample_name = :loop_amen
sample sample_nameHay tres razones principales para utilizar variables en Sonic Pi: comunicar significado, administrar repeticón y capturar los resultados de las cosas.
Cuando escribes código, es fácil pensar que sólo le dices a la computadora cómo hacer algo - mientras ella entienda, todo está bien. Sin embargo, es importante recordar que no sólo la computadora leerá el código. Otra gente podría leerlo e intentar comprender qué es lo que sucede. También sucede que quieras entender tu propio código en el futuro. Aunque pueda ser obvio para tí, ahora, ¡podría no serlo para otros o para tí en el futuro! When you write code it’s easy to just think you’re telling the computer how to do stuff - as long as the computer understands it’s OK. However, it’s important to remember that it’s not just the computer that reads the code. Other people may read it too and try to understand what’s going on. Also, you’re likely to read your own code in the future and try to understand what’s going on. Although it might seem obvious to you now - it might not be so obvious to others or even your future self!
Una forma de ayudar a otras personas a entender lo que hace tu código es escribir comentarios (como vimos en una sección anterior). Otra forma es utilizar nombres de variables significativos. Mira este código:
sleep 1.7533¿Por qué utiliza el número 1.7533? ¿de dónde proviene? ¿qué significa? Miremos el código siguiente:
loop_amen_duration = 1.7533
sleep loop_amen_durationAhora está mucho más claro lo que significa 1.7533: es la duración del sample :loop_amen! claro que puedes pensar que es mucho más simple escribir:
sleep sample_duration(:loop_amen)Lo cual es una muy buena manera de comunicar la intención del código.
a menudo ves muchas repeticiones en tu código y cuando quieres cambiar algo, tienes que cambiarlo enmuchos lugares. Mira este código:
sample :loop_amen
sleep sample_duration(:loop_amen)
sample :loop_amen, rate: 0.5
sleep sample_duration(:loop_amen, rate: 0.5)
sample :loop_amen
sleep sample_duration(:loop_amen)Estamos haciendo muchas cosas con :loop_amen! ¿qué pasa si quisiésemos escuchar otro sampleo como :loop_garzul? tendríamos que buscar y reemplazar todos los :loop_amen con :loop_garzul. Eso estaría bien si tienes mucho tiempo - pero ¿qué si está en vivo? algunas veces no tendrás el lujo del tiempo - especialmente si quieres que la gente se mantenga bailando.
¿qué tal si hubieses escrito tú código, así?:
sample_name = :loop_amen
sample sample_name
sleep sample_duration(sample_name)
sample sample_name, rate: 0.5
sleep sample_duration(sample_name, rate: 0.5)
sample sample_name
sleep sample_duration(sample_name)Eso hace exactamente lo mismo que lo anterior (pruébalo). también nos da la habilidad de cambiar una línea sample_name = :loop_amen a sample_name = :loop_garzul y podemos hacerlo en muchos lugares gracias a las variables.
Un buen motivo para utilizar variables es capturar los resultados de las cosas. Por ejemplo, quizás desees hacer algo con la duración de un sampleo:
sd = sample_duration(:loop_amen)Ahora podemos usar sd en cualquier lugar donde necesitemos la duración del sampleo :loop_amen.
Más importantemente, una variable nos permite capturar el resultado de una llamada a play o sample:
s = play 50, release: 8Ahora hemos atrapado y recordado s como una variable, lo que nos permite controlar el sintetizador mientras corre:
s = play 50, release: 8
sleep 2
control s, note: 62Veremos en más detalle cómo controlar los sintetizadores más tarde.
Si bien las variables son buenas para nombrar cosas y guardar los resultados de estas, es importante saber que, por lo general, solo deben usarse localmente dentro de un hilo. Por ejemplo, no hagas esto:
a = (ring 6, 5, 4, 3, 2, 1)
live_loop :sorted do
a = a.sort
sleep 0.5
puts "sorted: ", a
end
live_loop :shuffled do
a = a.shuffle
sleep 0.5
endIn the above example we assign a ring of numbers to a variable a and then used it within two separate live_loops. In the first live loop every 0.5s we sort the ring (to (ring 1, 2, 3, 4, 5, 6)) and then print it out to the log. If you run the code, you’ll find that the printed list is not always sorted!. This may surprise you - especially that sometimes the list is printed as sorted, and sometimes it is not. This is called non-deterministic behaviour and is the result of a rather nasty problem called a race-condition. The problem is due to the fact that the second live loop is also manipulating the list (in this case shuffling it) and by the time the list is printed, sometimes it has just been sorted and sometimes it has just been shuffled. Both live loops are racing to do something different to the same variable and every time round a different loop ‘wins’.
Hay dos soluciones a este problema. Primero, no utilices el miso variable en multiples live loops o subprocesos. Por ejemplo, el siguiente código imprimirá siempre una lista ordenada, porque cada live loop tiene su variable separado:
live_loop :shuffled do
a = (ring 6, 5, 4, 3, 2, 1)
a = a.shuffle
sleep 0.5
end
live_loop :sorted do
a = (ring 6, 5, 4, 3, 2, 1)
a = a.sort
sleep 0.5
puts "sorted: ", a
endSin embargo, a veces queremos compartir datos entre hilos. Por ejemplo, la clave actual, la velocidad, el sintetizador etc. En estos casos, se puede utilizar el sistema especial “thread-safe” de Sonic Pi a través de los fns get y set. Esto sera discutido luego en la sección 10.
Cuando estés lo suficientemente avanzado en live-coding con un número de funciones e hilos simultáneamente, notarás que es muy fácil cometer un error en uno de los hilos y eso lo mata. Eso no es gran cosa, porque puedes fácilmente recomenzar el hilo con apretar Run. Sin embargo, cuando recomiences el hilo estará out of time con los hilos actuales.
Como discutíamos anteriormente, nuevos hilos creados con in_thread heredan todos los seteos del hilo padre. Esto incluye el tiempo actual, lo que significa que los hilos estarán siempre en el tiempo con los demás cuando comenzados simultáneamente.
Sin embargo, cuando comienzas un hilo aparte, comienza con su propio tiempo que difícilmente estará sincronizado con alguno de los otros que estén siendo corridos.
Sonic Pi provee una solución a este problema con las funciones cue y sync.
cue permite enviar mensajes de pulso a todos los otros hilos, los cuales, en principio no están interesados e ignoran estos mensajes. Sin embargo. puedes registrar fácilmente su interés con la función sync.
Lo importante de notar es que sync es similar a sleep en que para el hilo actual por un tiempo. Sin embargo, con sleep tu especificas cuánto tiempo va a esperar, en cambio con sync no sabes cuánto tiempo esperará - ya que sync espera por el siguiente cue de otro hilo.
Exploremos esto en más detalle:
in_thread do
loop do
cue :tick
sleep 1
end
end
in_thread do
loop do
sync :tick
sample :drum_heavy_kick
end
endAquí tenemos dos hilos - uno actuando como un metrónomo, no haciendo sonidos sino que enviando :tick mensajes de pulso. El segundo hilo está sincronizandose con los mensajes de tick y cuando recibe uno, hereda el tiempo del hilo de cue y continúa tocando.
El resultado es que escuchamos el sample de :drum_heavy_kick exactamente cuando el otro hilo envía el mensaje :tick, aunque ambos hilos no comenzaron su ejecución al mismo tiempo:
in_thread do
loop do
cue :tick
sleep 1
end
end
sleep(0.3)
in_thread do
loop do
sync :tick
sample :drum_heavy_kick
end
endEsa llamada sleep típicamente haría que el segundo hilo vaya fuera de fase con el primero. Sin embargo, por estar usando cue y sync, sincronizamos ambos hilos automáticamente.
Eres libre de utilizar cualquier nombre que quieras a los mensajes de cue - no sólo :tick. Sólo debes asegurarte que los otros hilos estén sync sincronizándose en el nombre correctoe - de otro modo se quedarán esperando por siempre (o hasta presionar el botón de Parar)
Juguemos con unos cuantos nombres para cue:
in_thread do
loop do
cue [:foo, :bar, :baz].choose
sleep 0.5
end
end
in_thread do
loop do
sync :foo
sample :elec_beep
end
end
in_thread do
loop do
sync :bar
sample :elec_flip
end
end
in_thread do
loop do
sync :baz
sample :elec_blup
end
endAquí tenemos un cue principal bucleado, el cual envía aleatoriamente uno de los nombres de pulso :foo, :bar o :baz. Después tenemos también tres bucles de hilos sincronizándose entre ellos independientemente y tocando un sampleo diferente. El efecto es que escuchamos un sonido cada 0.5 pulsos que cada uno de los hilos está aleatoriamente sincronizándose sync con el hilo de cue y toca su sampleo.
Por supuesto que esto también funciona si ordenas los hilos en reversa, ya que los hilos sync siempre esperarán al siguiente cue.
Uno de los aspectos más satisfactorios y divertidos de Sonic Pi es su habilidad de añadir efectos de estudio a tus sonidos. Por ejemplo, si quieres añadir reverberación, eco o distorsión.
Sonic Pi provee una manera simple y poderosa de añadir efectos FX. Inclusive te permite encadenarlos (así pasas tus sonidos por la distorsión, después el eco y la reverberación). También controlar cada unidad individual de FX con operandos (similar a darle parámetros a los sintetizadores y sampleos). Inclusive puedes modificar los operandos del FX mientras se ejecutan. Por ejemplo, puedes incrementar la reverberación del bajo a través de la pista…
Si todo suena un poco complicado, no te preocupes. Una vez juegues con con esto, se aclarará. Antes de eso, una simple analogía es la de los pedales de efectos de una e-guitarra. Hay muchos pedales que puedes comprar. Algunos añaden reverberación, otros distorsión etc. Una guitarrista conecta su guitarra en un pedal, después a otro y así (cadena) La salida del pedal de reverberación termina siendo conectada al amplificador:
Guitarra -> Distorsión -> Reverberación -> AmplificadorEsto se llama efectos FX en cadena. Sonic Pi soporta eso. Adicionalmente cada pedal a menudo tiene diales y deslizadores para controlar cuánta distorsión, reverberación, eco etc. aplicar. Sonic Pi soporta También esta clase de control. Finalmente, imagina un guitarrista tocar mientras otra persona controla los efectos DX. Sonic Pic también permite esto, pero en vez de otra persona, te permite a tí controlarlo todo.
¡¡ Exploremos los efectos (FX) !!
En esta sección veremos los efectos: reverberación y eco. Veremos cómo usarlos, controlar sus operandos y encadenarlos. Llamaremos “FX” a los efectos.
El sistema de efectos de Sonic Pi, utiliza bloques. Así que si no has leído la sección 5.1, deberías.
Si queremos usar reverberación, escribimos with_fx :reverb como el código especial para nuestro bloque, así:
with_fx :reverb do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
endCuando tocas este código tendrá reverberación. ¿suena bien, no? todo suena mejor con reverberación.
Ahora veamos qué sucede si dejamos código fuera del bloque do/end:
with_fx :reverb do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
end
sleep 1
play 55Nota que el lay play 55 no se ejecutó con reberveración. Esto es porque está fuera del bloque do/end, así que no es capturado por el FX reverberación.
Similarmente, si haces sonidos antes del bloque do/end, tampoco los capturará:
play 55
sleep 1
with_fx :reverb do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
end
sleep 1
play 55Hay muchos FX (efectos) para escoger. ¿probamos con eco?
with_fx :echo do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
endUno de los aspectos más sobresalientes de Sonic Pi es que los bloques de efectos operan con parámetros similares a los utilizados con play y sample. Por ejemplo, un parámetro interesante es phase: que representa la duración de un eco dado en pulsos. Hagamos el eco más lento:
with_fx :echo, phase: 0.5 do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
endAhora hagamos el eco más rápido:
with_fx :echo, phase: 0.125 do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
endHagamos que al eco le tome 8 pulsos en desvanecerse, gracias a decay:
with_fx :echo, phase: 0.5, decay: 8 do
play 50
sleep 0.5
sample :elec_plip
sleep 0.5
play 62
endUno de los más poderosos aspectos de los bloques de FX es que puedes anidarlos, con lo que logramos encadenarlos con facilidad. Por ejemplo, si quisieras tocar código con eco y después reverberación, fácilmente pones un Fx dentro de otro:
with_fx :reverb do
with_fx :echo, phase: 0.5, decay: 8 do
play 50
sleep 0.5
sample :elec_blup
sleep 0.5
play 62
end
endPiensa en el audio fluir desde adentro. El sonido de todo el códido dentro del bloque interno do/end como play 50 es primero enviado al FX de eco y a su vez, éste es enviado al FX reverberación.
Podemos hacer uso de anidados muy profundos para resultados extremos. Sin embargo, ten presente que los Fx consumen muchos recursos y que al anidarlos estás de hecho corriendo muchos FX simultáneamente. Así que sé consciente de su uso, especialmente en plataformas de bajo rendimiento como la Raspberry Pi.
Sonic Pi tiene muchos efectos con los cuales jugar. Para verlos, cliquea en FX a la izquierda de este sistema de Ayuda y verás el listado. Aquí te deja algunos de mis favoritos:
tambaleo, reverberación, eco, distorsión rebanador
¡Ahora haz locuras con los FX, añadiéndolos en todas partes para crear nuevos sonidos!
Aunque a simple vista sean simples, los FX son - internamente - unas bestias complejas. Su simplicidad a veces promueve a que la gente los sobre use en su música. Esto no es un problema si tienes una máquina poderosa, pero si - como yo - usas una Raspberry Pi para tus jams, debes ser cuidadoso acerca de cuanto trabajo le asignas para asegurarte que todo fluya sin pausas.
Considera este código:
loop do
with_fx :reverb do
play 60, release: 0.1
sleep 0.125
end
endEn este código estamos tocando la nota 60 con un tiempo de release muy, corto, por lo que es una nota muy corta. También queríamos reverb, así que lo envolvimos en un bloque de reverberación. Todo bien, excepto…
Veamos lo que hace el código. Primero bucleamos para que se repita por siempre todo lo que está dentro de él. Después tenemos un bloque with_fx Esto significa que crearemos un FX reverberación cada vez que buclee. Esto es como tener un pedal de reverberación por cada vez que toques una cuerda de la guitarra. Es bueno poder hacerlo, pero no siempre lo querrás. Por ejemplo, este código tendrá dificultades en una Raspberry Pi. Todo el trabajo de crear la reverberación y después esperar hasta que ncesite ser parado y removido, es hecho por with_fx pero esto consume mucho del CPU.
¿cómo lo haríamos más similar a cuando un guitarrista tiene sólo un pedal de reverberación a través del cual pasan todos los sonidos? Simple:
with_fx :reverb do
loop do
play 60, release: 0.1
sleep 0.125
end
endPoniendo nuestro bucle dentro del bloque with_fx. Así sólo creamos un paso a reverb para todas las notas del bucle. Este código es mucho más eficiente y funcionará bien en una Raspberry Pi.
Al utilizar with_fx sobre una iteración en un bucle:
loop do
with_fx :reverb do
16.times do
play 60, release: 0.1
sleep 0.125
end
end
endDe esta forma, hemos sacado el with_fx fuera de la parte interna del loop y ahora estamos creando un nuevo reverb cada 16 notas.
Éste es un patrón tan común que with_fx ofrece una opción para hacer esto mismo, pero sin tener que escribir el bloque 16.times:
loop do
with_fx :reverb, reps: 16 do
play 60, release: 0.1
sleep 0.125
end
endAmbos ejemplos, reps: 16 y 16.times do, tendrán el mismo comportamiento. Básicamente, el reps: 16 repite el código dentro del bloque do/end 16 veces; así que puedes usar ambos de manera intercambiable, y utilizar aquel que te guste más.
Recuerda que no hay errores, sólo posibilidades. Sin embargo, según qué manera, se producen diferentes sonidos y características de ejecución. Así que experimenta y utiliza lo que te suene mejor y funcione en la plataforma que tengas.
Hasta ahora hemos visto cómo disparar sintetizadores y sampleos, cambiar sus operandores tales como amplitude, paneo, seteos de sobres y más. Cada sonido disparado es, esencialmente, su propio sonido con su lista de opciones por la duración del sonido.
¿Te gustaría cambiar los operadores de los sonidos cuando aún están sonando, así como cuando vibras la cuerda de una guitarra?
¡Tienes suerte, pues ésta sección te mostrará cómo hacerlo!
Hasta el momento nos hemos concentrado en disparar nuevos sonidos y FXs. Sin embargo, Sonic Pi te da la posibilidad de manipular y controlar sonidos en ejecución. Esto lo hacemos al utilizar una variable para capturar una referencia de un sintetizador:
s = play 60, release: 5Aquí utilizamos una variable de ejecución local, s que representa el sintetizador tocando la nota 60. Al ser local no puede ser accesada desde otras ejecuciones, como sucede con las funciones.
Con s, utilizaremos la función control:
s = play 60, release: 5
sleep 0.5
control s, note: 65
sleep 0.5
control s, note: 67
sleep 3
control s, note: 72Es de notar que no se disparan 4 diferentes sintetizadores, sino que usando uno al que le cambiamos los tonos 3 veces durante su ejecución.
Podemos pasar operandos para control como amp, cutoff: o pan:.
Algunos de los operandos no pueden ser controlados una vez comenzado el sintetizador. Este es el caso de los parámetros de sobres ADSR. Puedes encontrar cuáles operandos sí pueden ser controlados en el sistema de ayuda. Si la documentación dice no puede ser cambiado una vez seteado, es que no puedes controlar los operandos cuando el sintetizador ha comenzado.
También es posible controlar los efectos, aunque de una manera diferente:
with_fx :reverb do |r|
play 50
sleep 0.5
control r, mix: 0.7
play 55
sleep 1
control r, mix: 0.9
sleep 1
play 62
endEn vez de usar una variable, usamos parámetros de poste “|” de los bloques do/end. Dentro de los postes |, debemos especificar un nombre específico para nuestro efecto en ejecución, el cual después referenciaremos desde el bloque do/end que lo contiene. Esta conducta es idéntica a usar funciones parametricazadas.
¡Ahora ve a controlar sintetizadores y efectos! Now go and control some synths and FX!
Mientras explorábamos las opciones con sintetizadores y efectos, habrás notado que hay un número de opciones que terminan en _slide. Quizás intentaste utilizarlos y no hubo efecto. Esto es porque ellos son parámetros especiales que sólo funcionan cuando controlas los sintetizadores como dijimos en la sección anterior.
Considera el siguiente ejemplo:
s = play 60, release: 5
sleep 0.5
control s, note: 65
sleep 0.5
control s, note: 67
sleep 3
control s, note: 72Aquí puedes escuchar el sintetizador cambiando tono inmediatamente en cada llamada de control. Sin embargo, quizás querramos que el tono se deslice entre cambios. Ya que estamos controlando el parámetro note, para añadir deslizamiento (slide), debemos setear el note_slide del sintetizador:
s = play 60, release: 5, note_slide: 1
sleep 0.5
control s, note: 65
sleep 0.5
control s, note: 67
sleep 3
control s, note: 72Ahora escuchamos las notas “deslizadas” entre cada llamada de control. ¿suena bien, no? Puedes acelerar/desacelerar el arraster usando tiempos más cortos en note_slide: 0.2.
Cada parámetro que puede ser controlado, tiene su correspondiente _slide con el que jugar.
Una vez que determines un parámetro de _slide en un sintetizador, será recordado y usado cada vez que deslices el correspondiente parámetro. Para detener el deslizamiento, debes setear el valor de _slide a 0 antes de la siguiente llamada a control.
También es posible deslizar opciones de efectos (FX):
with_fx :wobble, phase: 1, phase_slide: 5 do |e|
use_synth :dsaw
play 50, release: 5
control e, phase: 0.025
endVe y diviértete deslizando todo para unas transiciones suaves y control fluído… Now have fun sliding things around for smooth transitions and flowing control…
Una herramiento útil para los programadores es la Estrutura de Datos.
Algunas veces puedes desear usar más de una cosa. Por ejemplo, el tocar una serie de notas que se toquen una después de la otra. Los lenguajes de programación tienen estructuras de datos para permitirte eso.
Hay muchas estructuras de datos exóticas y excitantes a disposición de los programadores - y se siguen inventando nuevas. Sin embargo, por ahora sólo necesitamos considerar una estructura de datos muy sencilla - la lista.
Mirémosla en mayor detalle. Cubriremos su forma básica y también el modo de utilizarlas para representar escalas y acordes.
En esta sección miraremos una Estructura de Datos muy útil: la Lista. Ya la vimos -brevemente- en la sección de aleatoriedad, cuando de una lista de notas elegía al azar las notas a tocar:
play choose([50, 55, 62])Ahora también exploraremos listas que que representan acordes y escalas. Primero repasemos cómo tocar un acorde. Recuerda que si no usamos sleep, todos los sonidos suceden al mismo tiempo:
play 52
play 55
play 59Veamos otras maneras de representar este código.
Una opción es colocar todas las notas en una lista: [52, 55, 59]. Nuestro amigable play es lo suficientemente listo para entender cómo tocar una lista de notas. Probemos:
play [52, 55, 59]Ohh, eso ya está mejor para leer. El tocar un listado de notas no significa que no puedas usar los otros parámetros, normalmente:
play [52, 55, 59], amp: 0.3Por supuesto, puedes usar los nombres tradicionales de notas en vez de números MIDI
play [:E3, :G3, :B3]Ahora, esos suertudos de ustedes con estudios en teoría musical, podrán reconocer que el acorde es Mi menor tocado en la 3ra octava.
Otro aspecto útil de una lista es la habilidad de obtener información de la misma. Puede sonar extraño, pero es igual a alguien pidiéndote que pases a la página 23 de un libro. Con una lista, dirías, ¿qué elemento hay en el índice 23? Lo único diferente es que en índices de programación se comienza con 0 y no con 1.
Con índices de listas no contamos 1, 2, 3… sino que 0, 1, 2…
Veamos eso en mayor detalle en esta lista:
[52, 55, 59]No hay algo espcialmente de susto en ello. Ahora, ¿qué es el segundo elemento en esa lista? Si, claro, es 55. Fácil. Veamos si la computadora puede respondernoslo, también:
puts [52, 55, 59][1]Si se mira algo raro, confía en mí, no lo es. Hay tres partes en la línea de arriba: la palabra puts, nuestra lista 52, 55, 59 y nuestro índice [1]. Primero pedimos puts para que Sonic Pi imprima la respuesta en la bitácora. Después, le damos nuestra lista y finalmente nuestro índice le pide el segundo elemento. Necesitamos rodear nuestro índice con paréntesis cuadrados y ya que el conteo comienza en 0, el índice para el segundo elemento es 1. Mira:
# indexes: 0 1 2
[52, 55, 59]Prueba con puts [52, 55, 59][1] y verás 55 en la bitácora. Cambia el índice 1 a otros índices, intenta con listas más largas en tu próximo código. Por ejemplo, estructuras musicales que podrían representarse como series de números
Sonic Pi soporta nombres de acordes que regresarán listas. Pruébalo:
play chord(:E3, :minor)¡Ahora estamos en algo!. Eso se mira mucho mejor que listas crudas y es más fácil de leer para otros. ¿qué otros acordes soporta Sonic Pi? Bueno, muchos. Prueba con estos:
chord(:E3, :m7)
chord(:E3, :minor)
chord(:E3, :dim7)
chord(:E3, :dom7)
Podemos convertir acordes en arpegios con facilidad, gracias a la función play_pattern:
play_pattern chord(:E3, :m7)Ok, eso no fue tan divertido, se ejecutó muy despacio. play_pattern va a tocar cada nota en la lista separada por una llamada a sleep 1 entre cada llamada a play. Podemos usar otra función play_pattern_timed para especificar nuestros propios tiempos y acelerar las cosas:
play_pattern_timed chord(:E3, :m7), 0.25Inclusive podemos pasar una lista de tiempos, los cuales serán tratados como un círculo de tiempos:
play_pattern_timed chord(:E3, :m13), [0.25, 0.5]Eso equivale a:
play 52
sleep 0.25
play 55
sleep 0.5
play 59
sleep 0.25
play 62
sleep 0.5
play 66
sleep 0.25
play 69
sleep 0.5
play 73¿qué preferirías escribir?
Sonic Pi incluye un gran rango de escalas. ¿qué tal tocar una escala de Do3 mayor?
play_pattern_timed scale(:c3, :major), 0.125, release: 0.1Podemos pedir para más octavas:
play_pattern_timed scale(:c3, :major, num_octaves: 3), 0.125, release: 0.1¿qué tal todas las notas de la escala pentatónica?
play_pattern_timed scale(:c3, :major_pentatonic, num_octaves: 3), 0.125, release: 0.1Los Acordes y Escalas son una buena manera de restringir una elección aleatoria para hacer algo significativo. Toca esl siguiente ejemplo que agarra notas al azar del acorde de E3 menor:
use_synth :tb303
loop do
play choose(chord(:E3, :minor)), release: 0.3, cutoff: rrand(60, 120)
sleep 0.25
endIntenta cambiar los nombres de acordes y los rangos de corte.
Para saber cuáles acordes y escalas vienen con Sonic Pi, simplemente cliquea el botón Lang a la izquierda de este tutorial y elige acorde o escala de la lista API. En la información en el panel principal, baja hasta ver una larga lista de acordes y escalas (dependiendo de cuál estés viendo).
¡Diviértete y siempre recuerda que no hay errores, sólo oportunidades!
Una variación interesante a las listas, son los anillos. Si sabes algo de programación, puedes haberte topado con anillos de buffers o arrays. Aquí sólo iremos con los anillos - es corto y simple.
En la sección anterior de listas, vimos cómo sacar elementos de ellas a través del mecanismo de indexado:
puts [52, 55, 59][1]Ahora, ¿qué sucede si quieres el índice 100? Bueno, claramente no existe un elemente en el índice 100, ya que sólo hay 3 elementos dentro. Así que Sonic Pi te responderá un nil.
Sin embargo, considera que tienes un contador tal como el pulso actual que se va incrementando. Hagamos nuestro contador y lista:
counter = 0
notes = [52, 55, 59]Ahora podemos usar nuestro contador para acceder a una nota de nuestra lista:
puts notes[counter]Grandioso, obtuvimos 52. Ahora, incrementemos nuestro contador y obtengamos otra nota:
counter = (inc counter)
puts notes[counter]Super, obtuvimos 55y después 59. Sin embargo, si lo hacemos de nuevo, se nos acaban los números de la lista y obtenemos nil. Si quisiésemos buclear y volver a comenzar la lista, usaríamos los anillos.
Podemos crear anillos de dos maneras: con la función ringy los elementos del anillo como parámetros:
(ring 52, 55, 59)O podemos tomar una lista normal y convertirla a anillo con el mensaje .ring:
[52, 55, 59].ringUn anillo puede ser utilizado de la misma manera que una lista, exceptuando que puedes usar índices negativos y mayores al tamaño del anillo mismo, los cuales envolverán y apuntarán siempre a alguno de los elementos del anillo:
(ring 52, 55, 59)[0] #=> 52
(ring 52, 55, 59)[1] #=> 55
(ring 52, 55, 59)[2] #=> 59
(ring 52, 55, 59)[3] #=> 52
(ring 52, 55, 59)[-1] #=> 59Usemos una variable para representar el número del pulso actual. Podemos usar esto como un índice a nuestro anillo para agarrar notas a ser tocadas o tiempos de release o cualquier cosa útil que tengamos en nuestro anillo, independientemente del pulso en el que estemos.
Algo útil de saber es que las listas regresadas por scale y acorde también son anillos que te permiten las accedas con índices arbitrarios.
Además de ring hay un número de funciones que construyen anillos por nosotros.
range pide especificar un punto de inicio, final y tamaño del paso.
bools permite usar 1s y 0s para representar booleanos.
knit permite conectar una secuencia de valores repetidos.
spread crea un anillo de booleanos con distribución euclideana.
Mira la documentación de cada uno para más información.
Otra forma de crear nuevos anillos, además de con constructores como range y spread, es manipulando anillos existentes.
Para explorar esta idea, mira el siguiente anillo:
(ring 10, 20, 30, 40, 50)¿Y si lo queremos de atrás a delante? Bueno, sólo tendríamos que usar el comando .reverse para coger el anillo y darle la vuelta:
(ring 10, 20, 30, 40, 50).reverse #=> (ring 50, 40, 30, 20, 10)Ahora bien, ¿y si queremos los tres primeros valores del anillo?
(ring 10, 20, 30, 40, 50).take(3) #=> (ring 10, 20, 30)Finalmente, ¿y si queremos mezclar (barajar) el anillo?
(ring 10, 20, 30, 40, 50).shuffle #=> (ring 40, 30, 10, 50, 20)Por sí sola, ésta es una forma muy potente de crear nuevos anillos. Sin embargo, el verdadero poder viene cuando encadenas unos cuantos de estos comandos juntos.
¿Y qué me dices de desordenar el anillo, quitarle 1 elemento, y después coger los siguientes 3?
Veamos esto por pasos:
(ring 10, 20, 30, 40, 50) - nuestro anillo inicial
(ring 10, 20, 30, 40, 50).shuffle - lo desordenamos - (ring 40, 30, 10, 50, 20)
(ring 10, 20, 30, 40, 50).shuffle.drop(1) - quitamos 1 - (ring 30, 10, 50, 20)
(ring 10, 20, 30, 40, 50).shuffle.drop(1).take(3) - cogemos 3 - (ring 30, 10, 50)
¿Ves cómo hemos creado una cadena larga de estos métodos con sólo unirlos? Podemos combinarlos en el orden que queramos; ésta es una forma extremadamente rica y potente de generar nuevos anillos a partir de anillos existentes.
Estos anillos tienen una propiedad muy poderosa e importante. Son inmutables, es decir, no pueden cambiar. Esto significa que la cadena de métodos descrita en esta sección no cambia anillos, sino que crea nuevos anillos. Por eso, puedes compartir anillos entre distintos hilos con total libertad; puedes encadenarlos dentro de un hilo sabiendo que ningún otro hilo usando el mismo anillo se va a ver afectado.
Aquí tienes una lista de los métodos de cadenas disponibles, para que juegues con ellos:
.reverse - devuelve una versión del anillo dado la vuelta
.sort - crea una versión ordenada del anillo
.shuffle - crea una versión desordenada del anillo
.pick(3) - devuelve un anillo que es el resultado de llamar .choose 3 veces
.pick(3) - devuelve un anillo que es el resultado de llamar .choose 3 veces
.take(5) - devuelve un anillo nuevo, que sólo contiene los primeros 5 elementos
.drop(3) - devuelve un anillo nuevo con todos los elementos salvo los 3 primeros
.butlast - devuelve un anillo nuevo sin el último elemento
.drop_last(3) - devuelve un nuevo anillo sin los 3 últimos elementos
.take_last(6)- devuelve un anillo nuevo con sólo los últimos 6 elementos
.stretch(2) - repite cada elemento en el anillo dos veces
.repeat(3) - repite el anillo entero 3 veces
.mirror - añade el anillo a una versión invertida del mismo
.reflect - lo mismo que mirror, pero no duplica el valor del medio
.scale(2) - devuelve un anillo nuevo con todos los elementos multiplicados por 2 (asume que el anillo sólo contiene números)
Por supuesto, estos métodos para cadenas con números, ¡pueden utilizar otros númros cualquiera! Así que, siéntete libre de llamar .drop(5) en vez de .drop(3) si quieres quitar los primeros 5 elementos.
Uno de los aspectos más excitantes de Sonic Pi es que permite escribir y modificar código ‘al vuelo’ para hacer música, así como harías con una guitarra. Una ventaja de esto es que te da más retroalimentación mientras compones (corre un bucle sencillo (juega con él hasta que sea perfecto). Sin embargo, la mayor ventaja es poder ejecutar Sonic Pi en vivo en escena.
En esta sección cubriremos lo fundamental de tornar tu código estático de composiciones en ejecuciones dinámicas.
¡Prepárate!
Ya sabemos lo suficiente para comenzar a divertirnos en serio. En esta sección te mostraré cómo comenzar a crear composiciones musicales en vivo y convertirlas en ejecuciones. Para ello necesitamos 3 ingredientes:
Habilidad para escribir código que haga sonidos - CHECK! Habilidad de escribir funciones - CHECK! Hbilidad de usar hilos (nominales) - CHECK!
¡Muy bien, comencemos! Hagamos nuestros primeros sonidos de códigos en vivo Primero necesitamos una función conteniendo el código que necesitamos tocar Comencemos con algo simple. También necesitamos llamadas en bucle a esa función en un hilo:
define :my_loop do
play 50
sleep 1
end
in_thread(name: :looper) do
loop do
my_loop
end
endSi te parece complicado, vuelve a leer las secciones de funciones e hilos. No es tan complicado una vez entiendes bien esos conceptos.
Lo que tenemos es una función que toca la nota 50 y duerme por un pulso. Después definimos un hilo llamado :looper que bucle llamando my_loop repetidamente.
Si corres este código, escucharás la nota 50 una y otra vez…
Aquí es donde comienza la diversión. Mientras el código aún corre cambia 50 a otro número, digamos 55, y presiona Run otra vez. ¡Woah! ¡cambió en vivo!
No añadió una nueva capa porque usamos hilos nombrados, los que sólo permiten un hilo por cada nombre. El sonido cambió porque redefinimos la función. LE dimos a :my_loopuna nueva definición. CUando el hilo :looper bucleó, simplemente llamó la nueva definición.
Sigue cambiándolo, cambia la nora, el tiempo de pausa. ¿qué tal añadir un use_synth? Por ejemplo, esto:
define :my_loop do
use_synth :tb303
play 50, release: 0.3
sleep 0.25
endAhora suena interesante, pero podemos mejorarlo, aún. En vez de tocar la misma nota, hagámoslo con un acorde:
define :my_loop do
use_synth :tb303
play chord(:e3, :minor), release: 0.3
sleep 0.5
end¿tocamos notas del acorde al azar?:
define :my_loop do
use_synth :tb303
play choose(chord(:e3, :minor)), release: 0.3
sleep 0.25
endo usando un valor de corte al azar:
define :my_loop do
use_synth :tb303
play choose(chord(:e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
sleep 0.25
endAl final, añadamos un poco de batería:
define :my_loop do
use_synth :tb303
sample :drum_bass_hard, rate: rrand(0.5, 2)
play choose(chord(:e3, :minor)), release: 0.2, cutoff: rrand(60, 130)
sleep 0.25
end¡Ahora está volviéndose excitante!
Sin embargo, antes de saltar y comenzar a Live Coding con funciones e hilos, lee la próxima sección sobre live_loop que cambiará la manera en la que codifiques con Sonic Pi para siempre…
Bien, ésta sección del tutorial es la joya de la corona. Si leyeses sólo una sección, debería ser ésta. Si leíste la sección previa sobre los Fundamentos de Live Coding, live_loop es una manera simple de hacer exactamente eso, pero sin tener que escribir tanto.
Si no leíste la sección anterior, live_loop es como mejor se puede tocar con Sonic Pi.
Toquemos algo. Escribe el siguiente código en un buffer nuevo:
live_loop :foo do
play 60
sleep 1
endPresiona el botón de Run. Escucharás un beep básico en cada pulso. Nada muy divertido en ello. Sin embargo, todavía no presiones Stop. Cambia el 60 a 65 y presiona otra vez Run.
¡Woah Se cambió automáticamente sin perder un tan sólo pulso!¡Esto es Live Coding!
Hagámoslo más a bajo, sólo cambiemos el código un poco:
live_loop :foo do
use_synth :prophet
play :e1, release: 8
sleep 8
endAhora aprieta Run
Movamos el punto de corte:
live_loop :foo do
use_synth :prophet
play :e1, release: 8, cutoff: rrand(70, 130)
sleep 8
endPresiona Run otra vez.
Añadamos baterías:
live_loop :foo do
sample :loop_garzul
use_synth :prophet
play :e1, release: 8, cutoff: rrand(70, 130)
sleep 8
endCambiemos la nota de e1 a c1:
live_loop :foo do
sample :loop_garzul
use_synth :prophet
play :c1, release: 8, cutoff: rrand(70, 130)
sleep 8
endAhora deja de leerme y cambia lo que quieras por tu cuenta. ¡Diviértete!
Considera el siguiente bucle en vivo:
live_loop :foo do
play 50
sleep 1
endQuizás te preguntas el por qué es importante el nombre foo, la respuesta es que es importante porque significa que este bucle es diferente de TODOS los otros.
Nunca pueden haber dos bucles en vivo con el mismo nombre ejecutándose simultáneamente
Esto significa que si queremos múltiples bucles concurrentes, debemos darles diferentes nombres:
live_loop :foo do
use_synth :prophet
play :c1, release: 8, cutoff: rrand(70, 130)
sleep 8
end
live_loop :bar do
sample :bd_haus
sleep 0.5
endAhora puedes actualizar y cambiar cada bucle independientemente y funcionará siempre.
Una cosa que ya habrás notado es que los bucles en vivo trabajan automáticamente automáticamente con el mecanismo de marca de hilos que exploramos anteriormente. Cada bucle en vivo genera un evento cue Gracias a ello podemos sincronizarlos para asegurar bucles sin pausa.
Considera este código mal sincronizado:
live_loop :foo do
play :e4, release: 0.5
sleep 0.4
end
live_loop :bar do
sample :bd_haus
sleep 1
endVeamos si podemos arreglar el timing y sincronizar sin parar. Primero, arreglemos el bucle :foo para hacer el factor de sleep 1 a algo como 0.5:
live_loop :foo do
play :e4, release: 0.5
sleep 0.5
end
live_loop :bar do
sample :bd_haus
sleep 1
endTodavía no terminamos, pues notarás que los pulsos no se alinean correctamente. Esto se debe a que los bucles están desfasados out of phase. Arreglemos Esto sincronizándolos entre sí:
live_loop :foo do
play :e4, release: 0.5
sleep 0.5
end
live_loop :bar do
sync :foo
sample :bd_haus
sleep 1
end¡Wow, todo está sincronizado ahora y sin parar!
¡Ahora ve y codifica en vivo con bucles en vivo!
Algo con lo que seguramente te encontrarás haciendo muchas veces al hacer live coding es buclear a través de anillos (rings), para poner notas a melodías, pausas a ritmos, progresiones de acordes, variaciones timbrales, etc. etc.
Sonic Pi provee una herramienta muy útil para trabajar con anillos dentro de bucles en vivo. Se llama el sistema de tick, que provee la habilidad de tickear a través de anillos. Veamos un ejemplo:
counter = 0
live_loop :arp do
play (scale :e3, :minor_pentatonic)[counter], release: 0.1
counter += 1
sleep 0.125
endEsto es equivalente a:
live_loop :arp do
play (scale :e3, :minor_pentatonic).tick, release: 0.1
sleep 0.125
endAquí, simplemente tomamos la escala pentatónica menor de E3 y tickeamos a cada elemento al añadirles .tick al final de la declaración de escala. Este tick es local al bucle en vivo, por lo que cada bucle debe tener su propio e independiente tick:
live_loop :arp do
play (scale :e3, :minor_pentatonic).tick, release: 0.1
sleep 0.125
end
live_loop :arp2 do
use_synth :dsaw
play (scale :e2, :minor_pentatonic, num_octaves: 3).tick, release: 0.25
sleep 0.25
endTambién puedes llamar tick como una función estándar y usar el valor como un índice:
live_loop :arp do
idx = tick
play (scale :e3, :minor_pentatonic)[idx], release: 0.1
sleep 0.125
endSin embargo, es mejor llamar .tick al final. La función tick está para cuando quieras hacer cosas sofisticadas con el valor de tick y para cuando quieras hacer más que indexar dentro de los anillos.
Lo mágico acerca de tick es que no sólo te da un nuevo índice (o el valor del anillo en ese índice), sino que también te asegura que al próximo llamado de tick, será el próximo valor. Mira los documentos para ver ejemplos de trabajar con tick . Sin embargo, por ahora es importante notar que a veces querrás mirar al valor tick actual sin que aumente, lo cual se logra con la función look. La cual puede ser utilizada como una función estándar o añadiendo .look al final de un anillo. to the end of a ring.
Finalmente, algunas veces necesitarás más de un tick por bucle en vivo. Esto lo lograrás nombrando a tus ticks:
live_loop :arp do
play (scale :e3, :minor_pentatonic).tick(:foo), release: 0.1
sleep (ring 0.125, 0.25).tick(:bar)
endAquí estamos utilizando dos ticks, uno para la nota a ser tocada y otro para el tiempo de pausa. Como ambos están en el mismo bucle, debemos separarlos nombrándolos diferentemente. Es lo mismo que hiciéramos con live_loop - pasamos un símbolo prefijado con un :. En el anterior ejemplo, llamamos a un tick :foo y al otro :bar. Si queremos mirarlos sólo debemos pasar el nombre del tick a look.
La mayor parte del poder del sistema de tick no es útil al comenzar. No intentes aprender todo en esta sección, enfócate en el tick de un sólo anillo. Eso es lo que más te beneficiará y simplificará tickear dentro de anillos en bucles en vivo.
Mira la documentación de tick, donde tienes muchos ejemplos..
Often it is useful to have information that is shared across multiple threads or live loops. For example, you might want to share a notion of the current key, BPM or even more abstract concepts such as the current ‘complexity’ (which you’d potentially interpret in different ways across different threads). We also don’t want to lose any of our existing determinism guarantees when doing this. In other words, we’d still like to be able to share code with others and know exactly what they’ll hear when they run it. At the end of Section 5.6 of this tutorial we briefly discussed why we should not use variables to share information across threads due to a loss of determinism (in turn due to race conditions).
Sonic Pi’s solution to the problem of easily working with global variables in a deterministic way is through a novel system it calls Time State. This might sound complex and difficult (in fact, in the UK, programming with multiple threads and shared memory is typically a university level subject). However, as you’ll see, just like playing your first note, Sonic Pi makes it incredibly simple to share state across threads whilst still keeping your programs thread-safe and deterministic..
Dales la bienvenida a get y set…
Sonic Pi has a global memory store called Time State. The two main things you do with it are to set information and get information. Let’s dive deeper…
To store information into the Time State we need two things:
los datos que queremos almacenar, un nombre único (clave) para los datos.
Por ejemplo, puede ser que queremos almacenar el número 3000 con la clave :intensity. Eso es posible utilizando la función set:
set :intensity, 3000Podemos utilizar cualquier nombre para nuestra clave. Si esta clave ya tiene datos almacenados, nuestro nuevo set tendrá primacía.
set :intensity, 1000
set :intensity, 3000In the above example, as we stored both numbers under the same key, the last call to set ‘wins’, so the number associated with :intensity will be 3000 as the first call to set is effectively overridden.
To fetch information from the Time State we just need the key we used to set it, which in our case is :intensity. We then just need to call get[:intensity] which we can see by printing out the result to the log:
print get[:intensity] #=> imprime 3000Notice that calls to get can return information that was set in a previous run. Once a piece of information has been set it is available until either the information is overridden (just like we clobbered the :intensity value of 1000 to 3000 above) or Sonic Pi is closed.
The main benefit of the Time State system is that it can be safely used across threads or live loops. For example, you could have one live loop setting information and another one getting it:
live_loop :setter do
set :foo, rrand(70, 130)
sleep 1
end
live_loop :getter do
puts get[:foo]
sleep 0.5
endThe nice thing about using get and set across threads like this is that it will always produce the same result every time you hit run. Go on, try it. See if you get the following in your log:
{run: 0, time: 0.0}
└─ 125.72265625
{run: 0, time: 0.5}
└─ 125.72265625
{run: 0, time: 1.0}
└─ 76.26220703125
{run: 0, time: 1.5}
└─ 76.26220703125
{run: 0, time: 2.0}
└─ 114.93408203125
{run: 0, time: 2.5}
└─ 114.93408203125
{run: 0, time: 3.0}
└─ 75.6048583984375
{run: 0, time: 3.5}
└─ 75.6048583984375Try running it a few times - see, it’s the same every time. This is what we call deterministic behaviour and it’s really very important when we want to share our music as code and know that the person playing the code is hearing exactly what we wanted them to hear (just like playing an MP3 or internet stream sounds the same for all listeners).
rand
## An Example of Non-Deterministic Behaviour
## (due to race conditions caused by multiple
## live loops manipulating the same variable
## at the same time).
##
## If you run this code you'll notice
## that the list that's printed is
## not always sorted!
a = (ring 6, 5, 4, 3, 2, 1)
live_loop :shuffled do
a = a.shuffle
sleep 0.5
end
live_loop :sorted do
a = a.sort
sleep 0.5
puts "sorted: ", a
endLet’s take a look at how this might look using get and set:
## An Example of Deterministic Behaviour
## (despite concurrent access of shared state)
## using Sonic Pi's new Time State system.
##
## When this code is executed, the list that's
## printed is always sorted!
set :a, (ring 6, 5, 4, 3, 2, 1)
live_loop :shuffled do
set :a, get[:a].shuffle
sleep 0.5
end
live_loop :sorted do
set :a, get[:a].sort
sleep 0.5
puts "sorted: ", get[:a]
endNotice how this code is pretty much identical to the version using a variable before it. However when you run the code, it behaves as you would expect with any typical Sonic Pi code - it does the same thing every time in this case thanks to the Time State system.
Therefore, when sharing information across live loops and threads, use get and set instead of variables for deterministic, reproducible behaviour.
Section 5.7 introduced the functions cue and sync when dealing with the issue of synchronising threads. What it didn’t explain was that it is the Time State system which provides this functionality. It just so happens that set is actually a variation of cue and is built on top of the same core functionality which is to insert information into the Time State system. Additionally, sync is also designed in such a way that it works seamlessly with Time State - any information that we plan to store in Time State we can sync on. In other words - we sync on events yet to be inserted into Time State.
Let’s take a quick look at how to use sync to wait for new events to be added to Time State:
in_thread do
sync :foo
sample :ambi_lunar_land
end
sleep 2
set :foo, 1foo
Note that sync always waits for future events and that it will block the current thread waiting for a new event. Also, it will inherit the logical time of the thread which triggered it via set or cue so it may also be used to sync time.
foo
sample :ambi_lunar_landNote that values that are passed through set and cue must be thread safe - i.e. immutable rings, numbers, symbols or frozen strings. Sonic Pi will throw an error if the value you are attempting to store in the Time State is not valid.
foo
Let’s assume we want to wait for the next event that has three path segments:
sync "/*/*/*"This will match any Time State event with exactly three path segments, regardless of their names. For example:
foo
foo
cue "/eggs/beans/toast"
cue "/moog/synths/rule"
However, it will not match paths with fewer or more path segments. The following will not match:
foo
foo
cue "/eggs"
Each * means any content. So we could match paths with just one segment with /* or paths with five segments with /*/*/*/*/*
foo
foo foo foo
However, it wouldn’t match the following:
foo foo foo
foo
foo
foo foo foo foo
You can use the ? character to match against a single char such as "/?oo/bar/baz" which will match:
foo
cue "/goo/bar/baz"
cue "/too/bar/baz"
cue "/woo/bar/baz"
foo
foo foo foo
foo
foo foo foo
foo
foo foo foo foo foo
When calling sync or get you are free to combine matchers in any order you see fit to powerfully match any Time State event created by cue or set. Let’s look at a crazy example:
sample :loop_amenFor those curious, these matching rules are based on the Open Sound Control pattern matching specification which is explained in detail here: http://opensoundcontrol.org/spec-1_0
Once you’ve mastered converting code to music, you might wonder - what’s next? Sometimes the constraints of working purely within Sonic Pi’s syntax and sound system can be exciting and put you into a new creative position. However, sometimes it is essential to break out of the code into the real world. We want two extra things:
To be able to convert actions in the real world into Sonic Pi events to code with To be able to use Sonic Pi’s strong timing model and semantics to control and manipulate objects in the real world
Luckily there’s a protocol that’s been around since the 80s that enables exactly this kind of interaction - MIDI. There’s an incredible number of external devices including keyboards, controllers, sequencers, and pro audio software that all support MIDI. We can use MIDI to receive data and also use it to send data.
Sonic Pi provides full support for the MIDI protocol enabling you to connect your live code to the real world. Let’s explore it further…
In this section we will learn how to connect a MIDI controller to send events into Sonic Pi to control our synths and sounds. Go and grab a MIDI controller such as a keyboard or control surface and let’s get physical!
In order to get information from an external MIDI device into Sonic Pi we first need to connect it to our computer. Typically this will be via a USB connection, although older equipment will have a 5-pin DIN connector for which you’ll need hardware support for your computer (for example, some sound cards have MIDI DIN connectors). Once you’ve connected your device, launch Sonic Pi and take a look at the IO section of the Preferences panel. You should see your device listed there. If not, try hitting the ‘Reset MIDI’ button and see if it appears. If you’re still not seeing anything, the next thing to try is to consult your operating system’s MIDI config to see if it sees your device. Failing all that, feel free to ask questions in our friendly forums: https://in-thread.sonic-pi.net
Once your device is connected, Sonic Pi will automatically receive events. You can see for yourself by manipulating your MIDI device and looking at the cue logger in the bottom right of the application window below the log (if this isn’t visible go to Preferences->Editor->Show & Hide and enable the ‘Show cue log’ tickbox). You’ll see a stream of events such as:
/midi:nanokey2_keyboard:0:1/note_off [55, 64]
/midi:nanokey2_keyboard:0:1/note_on [53, 102]
/midi:nanokey2_keyboard:0:1/note_off [57, 64]
/midi:nanokey2_keyboard:0:1/note_off [53, 64]
/midi:nanokey2_keyboard:0:1/note_on [57, 87]
/midi:nanokey2_keyboard:0:1/note_on [55, 81]
/midi:nanokey2_keyboard:0:1/note_on [53, 96]
/midi:nanokey2_keyboard:0:1/note_off [55, 64]Once you can see a stream of messages like this, you’ve successfully connected your MIDI device. Congratulations, let’s see what we can do with it!
Estado del Tiempo (Time State)
Now we’ve connected a MIDI device, seen its events in the cue log and discovered that our knowledge of Time State is all we need to work with the events, we can now start having fun. Let’s build a simple MIDI piano:
live_loop :midi_piano do
note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
synth :piano, note: note
endThere’s a few things going on in the code above including some issues. Firstly, we have a simple live_loop which will repeat forever running the code between the do/end block. This was introduced in Section 9.2. Secondly, we’re calling sync to wait for the next matching Time State event. We use a string representing the MIDI message we’re looking for (which is the same as was displayed in the cue logger). Notice that this long string is provided to you by Sonic Pi’s autocompletion system, so you don’t have to type it all out by hand. In the log we saw that there were two values for each MIDI note on event, so we assign the result to two separate variables note and velocity. Finally we trigger the :piano synth passing our note.
Now, you try it. Type in the code above, replace the sync key with a string matching your specific MIDI device and hit Run. Hey presto, you have a working piano! However, you’ll probably notice a couple of problems: firstly all the notes are the same volume regardless of how hard you hit the keyboard. This can be easily fixed by using the velocity MIDI value and converting it to an amplitude. Given that MIDI has a range of 0->127, to convert this number to a value between 0->1 we just need to divide it by 127:
live_loop :midi_piano do
note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
synth :piano, note: note, amp: velocity / 127.0
endUpdate the code and hit Run again. Now the velocity of the keyboard is honoured. Next, let’s get rid of that pesky pause.
Before we can remove the pause, we need to know why it’s there. In order to keep all the synths and FX well-timed across a variety of differently capable CPUs, Sonic Pi schedules the audio in advance by 0.5s by default. (Note that this added latency can be configured via the fns set_sched_ahead_time! and use_sched_ahead_time). This 0.5s latency is being added to our :piano synth triggers as it is added to all synths triggered by Sonic Pi. Typically we really want this added latency as it means all synths will be well timed. However, this only makes sense for synths triggered by code using play and sleep. In this case, we’re actually triggering the :piano synth with our external MIDI device and therefore don’t want Sonic Pi to control the timing for us. We can turn off this latency with the command use_real_time which disables the latency for the current thread. This means you can use real time mode for live loops that have their timing controlled by syncing with external devices, and keep the default latency for all other live loops. Let’s see:
live_loop :midi_piano do
use_real_time
note, velocity = sync "/midi:nanokey2_keyboard:0:1/note_on"
synth :piano, note: note, amp: velocity / 127.0
endUpdate your code to match the code above and hit Run again. Now we have a low latency piano with variable velocity coded in just 5 lines. Wasn’t that easy!
Finally, as our MIDI events are going straight into the Time State, we can also use the get fn to retrieve the last seen value. This doesn’t block the current thread and returns nil if there’s no value to be found (which you can override by passing a default value - see the docs for get). Remember that you can call get in any thread at any time to see the latest matching Time State value. You can even use time_warp to jump back in time and call get to see past events…
Elegir (choose)
In addition to receiving MIDI events we can also send out MIDI events to trigger and control external hardware synths, keyboards and other devices. Sonic Pi provides a full set of fns for sending various MIDI messages such as:
Note on - midi_note_on
Note off - midi_note_off
Control change - midi_cc
Pitch bend - midi_pitch_bend
Clock ticks - midi_clock_tick
There are many other supported MIDI messages too - check out the API documentation for all the other fns that start with midi_.
In order to send a MIDI message to an external device, we must first have connected it. Check out the subsection ‘Connecting a MIDI Controller’ in section 11.1 for further details. Note that if you’re using USB, connecting to a device which you’re sending to (rather than receiving from) is the same procedure. However, if you’re using the classic DIN connectors, make sure you connect to the MIDI out port of your computer. You should see your MIDI device listed in the preferences pane.
The many midi_* fns work just like play, sample and synth in that they send a message at the current (logical) time. For example, to spread out calls to the midi_* fns you need to use sleep just like you did with play. Let’s take a look:
midi_note_on :e3, 50This will send a MIDI note on event to the connected MIDI device with velocity 50. (Note that Sonic Pi will automatically convert notes in the form :e3 to their corresponding MIDI number such as 52 in this case.)
If your connected MIDI device is a synthesiser, you should be able to hear it playing a note. To disable it use midi_note_off:
midi_note_off :e3By default, Sonic Pi will send each MIDI message to all connected devices on all MIDI channels. This is to make it easy to work with a single connected device without having to configure anything. However, sometimes a MIDI device will treat MIDI channels in a special way (perhaps each note has a separate channel) and also you may wish to connect more than one MIDI device at the same time. In more complicated setups, you may wish to be more selective about which MIDI device receives which message(s) and on which channel.
We can specify which device to send to using the port: opt, using the device name as displayed in the preferences:
midi_note_on :e3, port: "moog_minitaur"We can also specify which channel to send to using the channel: opt (using a value in the range 1-16):
midi_note_on :e3, channel: 3Of course we can also specify both at the same time to send to a specific device on a specific channel:
midi_note_on :e3, port: "moog_minitaur", channel: 5Finally, a really fun thing to do is to connect the audio output of your MIDI synthesiser to one of the audio inputs of your soundcard. You can then control your synth with code using the midi_* fns and also manipulate the audio using live_audio and FX:
reverberación,(The fn midi is available as a handy shortcut to sending both note on and note off events with a single command. Check out its documentation for further information).
In addition to MIDI, another way to get information in and out of Sonic Pi is via the network using a simple protocol called OSC - Open Sound Control. This will let you send messages to and from external programs (both running on your computer and on external computers) which opens up the potential for control way beyond MIDI which has limitations due to its 1980s design.
For example, you could write a program in another programming language which sends and receives OSC (there are OSC libraries for pretty much every common language) and work directly with Sonic Pi. What you can use this for is only limited by your imagination.
Estado del Tiempo (Time State)
Let’s build a basic OSC listener:
fooIn this example we described an OSC path "/osc*/trigger/prophet" which we’re syncing on. This can be any valid OSC path (all letters and numbers are supported and the / is used like in a URL to break up the path to multiple words). The /osc prefix is added by Sonic Pi to all incoming OSC messages, so we need to send an OSC message with the path /trigger/prophet for our sync to stop blocking and the prophet synth to be triggered.
We can send OSC to Sonic Pi from any programming language that has an OSC library. For example, if we’re sending OSC from Python we might do something like this:
from pythonosc import osc_message_builder
from pythonosc import udp_client
sender = udp_client.SimpleUDPClient('127.0.0.1', 4560)
sender.send_message('/trigger/prophet', [70, 100, 8])Or, if we’re sending OSC from Clojure we might do something like this from the REPL:
(use 'overtone.core)
(def c (osc-client "127.0.0.1" 4560))
(osc-send c "/trigger/prophet" 70 100 8)For security reasons, by default Sonic Pi does not let remote machines send it OSC messages. However, you can enable support for remote machines in Preferences->IO->Network->Receive Remote OSC Messages. Once you’ve enabled this, you can receive OSC messages from any computer on your network. Typically the sending machine will need to know your IP address (a unique identifier for your computer on your network - kind of like a phone number or an email address). You can discover the IP address of your computer by looking at the IO section of the preferences pane. (If your machine happens to have more than one IP address, hovering the mouse over the listed address will pop up with a list of all known addresses).
Note, some programs such as TouchOSC for iPhone and Android support sending OSC as a standard feature. So, once you’re listening to remote machines and know your IP address you can instantly start sending messages from apps like TouchOSC which enable you to build your own custom touch controls with sliders, buttons, dials etc. This can provide you with an enormous range of input options.
In addition to receiving OSC and working with it using Time State, we can also send out OSC messages in time with our music (just like we can send out MIDI messages in time with our music). We just need to know which IP address and port we’re sending to. Let’s give it a try:
use_osc "localhost", 4560
osc "/hello/world"If you run the code above, you’ll notice that Sonic Pi is sending itself an OSC message! This is because we set the IP address to the current machine and the port to the default OSC in port. This is essentially the same as posting a letter to yourself - the OSC packet is created, leaves Sonic Pi, gets to the network stack of the operating system which then routes the packed back to Sonic Pi and then it’s received as a standard OSC message and is visible in the cue logger as the incoming message /osc:127.0.0.1:4560/hello/world. (Notice how Sonic Pi automatically prefixes all incoming OSC messages with /osc and then the hostname and port of the sender.)
Of course, sending OSC messages to ourselves may be fun but it’s not that useful. The real benefit starts when we send messages to other programs:
use_osc "localhost", 123456
osc "/hello/world"In this case we’re assuming there’s another program on the same machine listening to port 123456. If there is, then it will receive a "/hello/world OSC message with which it can do what it wants.
If our program is running on another machine, we need to know its IP address which we use instead of "localhost":
use_osc "192.168.10.23", 123456
osc "/hello/world"Now we can send OSC messages to any device reachable to us via our local networks and even the internet!
So far, in terms of sound production, we’ve explored triggering synths and recorded sounds via the fns play, synth and sample. These have then generated audio which has played through our stereo speaker system. However, many computers also have the ability to input sound, perhaps through a microphone, in addition to the ability to send sound out to more than two speakers. Often, this capability is made possible through the use of an external sound card - these are available for all platforms. In this section of the tutorial we’ll take a look at how we can take advantage of these external sound cards and effortlessly work with multiple channels of audio in and out of Sonic Pi.
One simple (and perhaps familiar) way of accessing sound inputs is using our friend synth by specifying the :sound_in synth:
synth :sound_inThis will operate just like any synth such as synth :dsaw with the exception that the audio generated will be read directly from the first input of your system’s sound card. On laptops, this is typically the built-in microphone, but if you have an external sound card, you can plug any audio input to the first input.
One thing you might notice is that just like synth :dsaw the :sound_in synth only lasts for 1 beat as it has a standard envelope. If you’d like to keep it open for a little longer, change the ADSR envelope settings. For example the following will keep the synth open for 8 beats before closing the connection:
synth :sound_in, sustain: 8Of course, just like any normal synth, you can easily layer on effects with the FX block:
with_fx :reverb do
with_fx :distortion do
synth :sound_in, sustain: 8
end
endIf you have plugged in a guitar to your first input, you should be able to hear it with distortion and reverb until the synth terminates as expected.
You are free to use the :sound_in synth as many times as you like concurrently (just like you would do with any normal synth). For example, the following will play two :sound_in synths at the same time - one through distortion and one through reverb:
with_fx :distortion do
synth :sound_in, sustain: 8
end
with_fx :reverb do
synth :sound_in, sustain: 8
endYou can select which audio input you want to play with the input: opt. You can also specify a stereo input (two consecutive inputs) using the :sound_in_stereo synth. For example, if you have a sound card with at least three inputs, you can treat the first two as a stereo stream and add distortion and the third as a mono stream and add reverb with the following code:
with_fx :distortion do
synth :sound_in_stereo, sustain: 8, input: 1
end
with_fx :reverb do
synth :sound_in, sustain: 8, input: 3
endHowever, although this is a useful technique, there are a couple of limitations to this approach. Firstly, it only works for a specific duration (due to it having an ADSR envelope) and secondly, there’s no way to switch the FX around once the synth has been triggered. Both of these things are typical requests when working with external audio feeds such as microphones, guitars and external synthesisers. We’ll therefore take a look at Sonic Pi’s solution to the problem of manipulating a (potentially) infinite stream of live audio input: live_audio.
The :sound_in synth as described in the previous section provides a very flexible and familiar method for working with input audio. However, as also discussed it has a few issues when working with a single input of audio as a single instrument (such as a voice or guitar). By far the best approach to working with a single continuous stream of audio is to use live_audio.
live_audio shares a couple of core design constraints with live_loop (hence the similar name). Firstly it must have a unique name and secondly only one live_audio stream with that name may exist at any one time. Let’s take a look:
fooThis code will act in a similar fashion to synth :sound_in with some key differences: it runs forever (until you explicitly stop it) and you can move it to new FX contexts dynamically.
On initial triggering live_audio works exactly as you might expect it to work with FX. For example, to start a live audio stream with added reverb simply use a :reverb FX block:
fooHowever, given that live_audio runs forever (at least until you stop it) it would be pretty limiting if, like typical synths, the live audio was bound within the :reverb FX for its entire existence. Luckily this is not the case and it was designed to be easy to move between different FX. Let’s try it. Run the code above to hear live audio coming directly from the first input of your sound card. Note, if you’re using a laptop, this will typically be out of your built-in microphone, so it’s recommended to use headphones to stop feedback.
reverberación,
fooNow, hit Run, and you’ll immediately hear the audio played through the echo FX and no longer through reverb. If you wanted them both, just edit the code again and hit Run:
foofoo
Unlike standard synths, as live_audio has no envelope, it will continue running forever (even if you delete the code, just like a function is still defined in memory if you delete the code in the editor). To stop it, you need to use the :stop arg:
fooIt can easily be restarted by calling it without the :stop arg again:
fooAdditionally all running live audio synths are stopped when you hit the global Stop button (as with all other running synths and FX).
With respect to audio channels, by default live_audio acts similarly to the :sound_in synth in that it takes a single mono input stream of audio and converts it to a stereo stream using the specified panning. However, just like :sound_in_stereo it’s also possible to tell live_audio to read two consecutive audio inputs and treat them as the left and right channels directly. This is achieved via the :stereo opt. For example, to treat input 2 as the left signal and input 3 as the right signal, you need to configure the input: opt to 2 and enable stereo mode as follows:
fooNote that once you have started a live audio stream in stereo mode, you cannot change it to mono without stopping and starting. Similarly, if you start it in the default mono mode, you can’t switch to stereo without starting and stopping the stream.
So far in this section we’ve looked at how to get multiple streams of audio into Sonic Pi - either through the use of the :sound_in synth or via the powerful live_audio system. In addition to working with multiple streams of input audio, Sonic Pi can also output multiple streams of audio. This is achieved via the :sound_out FX.
Let’s quickly recap on how Sonic Pi’s synths and FX output their audio to their current FX context. For example, consider the following:
with_fx :reverb do # C
with_fx :echo do # B
sample :bd_haus # A
end
endThe simplest way to understand what’s happening with the audio stream is to start at the innermost audio context and work our way out. In this case, the innermost context is labelled A and is the :bd_haus sample being triggered. The audio for this goes directly into its context which is B - the :echo FX. This then adds echo to the incoming audio and outputs it to its context which is C - the :reverb FX. This then adds reverb to the incoming audio and outputs to its context which is the top level - the left and right speakers (outputs 1 and 2 in your audio card). The audio flows outwards with a stereo signal all the way through.
The above behaviour is true for all synths (including live_audio) and the majority of FX with the exception of :sound_out. The :sound_out FX does two things. Firstly it outputs its audio to its external context as described above. Secondly it also outputs its audio directly to an output on your sound card. Let’s take a look:
with_fx :reverb do # C
with_fx :sound_out, output: 3 do # B
sample :bd_haus # A
end
endIn this example, our :bd_haus sample outputs its audio to its external context which is the :sound_out FX. This in turn outputs its audio to its external context the :reverb FX (as expected). However, it also outputs a mono mix to the 3rd output of the system’s soundcard. The audio generated within :sound_out therefore has two destinations - the :reverb FX and audio card output 3.
Elegir (choose)
As we have also seen, the default behaviour for :sound_out and :sound_out_stereo is to send the audio both to their external context (as is typical of all FX) and to the specified output on your soundcard. However, occasionally you may wish to only send to the output on your soundcard and not to the external context (and therefore not have any chance of the sound being mixed and sent to the standard output channels 1 and 2). This is possible by using the standard FX opt amp: which operates on the audio after the FX has been able to manipulate the audio:
sample :loop_amenIn the above example, the :loop_amen sample is sent to its outer context, the :sound_out FX. This then sends a mono mix to audio card output 3 and then multiplies the audio by 0 which essentially silences it. It is this silenced signal which is then sent out to the :sound_out’s outer context which is the standard output. Therefore with this code, the default output channels will not receive any audio, and channel 3 will receive a mono mix of the amen drum break.
Con esto concluye el tutorial introductorio a Sonic Pi. Ojalá hayas aprendido algo por el camino. No te preocupes si crees que no entendiste todo - sólo juega y diviértete y verás que entiendes a tu propio ritmo - Vuelve cuando tengas alguna duda que pueda haber sido cubierta en una de las secciones.
Si tienes preguntas que no están cubiertas en el tutorial, por favor dirígete a Sonic Pi forums y haz tu pregunta. Seguro encuentras alguien amistoso que te eche una mano.
Finalmente, te invito a que estudies el resto de la documentación en el sistema de ayuda. Hay un número de características no cubiertas en el tutorial que esperan a ser descubiertas.
Así que juega, diviértete, comparte código con amigos, muestra tu pantalla y recuerda:
No hay errores, sólo oportunidades.
El Apéndice A contiene todos los artículos de Sonic Pi escritos para la revista MagPi.
Estos artículos no están pensados para ser leídos en un orden concreto, y contienen un montón de referencias a este tutorial. En vez de intentar enseñarte todo Sonic Pi, cada artículo se centra en un aspecto específico del lenguaje, y lo explica de forma divertida y accesible.
Puedes verlos con letras gloriosas y profesionales en la sección de descargas PDF gratuitas de MagPi, aquí: https://www.raspberrypi.org/magpi/
Si no encuentras un tema que te interese en estos artículos… ¿por qué no lo sugieres? La forma más fácil de hacerlo es que tuitees tus sugerencias a @Sonic_Pi. Nunca se sabe; ¡tu sugerencia podría ser el tema del próximo artículo!
La lección más importante que debes aprender de Sonic Pi es que realmente no hay errores. La mejor forma de aprender es sencillamente probar, probar y probar. Prueba un montón de cosas, deja de preocuparte de si tu código suena bien o no y empieza a experimentar con tantos sintetizadores, notas, FX y opciones como puedas. Quita las cosas que no te gusten y deja las cosas que te gusten, sencilamente. Cuantos más ‘errores’ te permitas hacer, más rápido aprenderás y descubrirás tu propio sonido al hacer código.
¿Ya has dominado lo esencial de Sonic Pi haciendo sonidos con sample y play? ¿Y ahora, qué? ¿Sabías que Sonic Pi ofrece hasta 27 efectos FX de estudio para cambiar el sonido de tu código? Los efectos son como filtros imagen chulos para los programas de dibujo, sólo que en vez de difuminar o hacer algo blanco y negro, puedes añadir cosas como reverberación, distorsión y eco a tu sonido. Piensa en lo que haces cuando conectas el cable de tu guitarra con un pedal de efectos que te guste, que a su vez va a un amplificador. Por suerte, usar efectos en Sonic Pi es muy fácil, ¡y no necesitas cables! Sólo necesitas escoger la sección de tu código a la que le quieras añadir el efecto, y envolverla con el código del mismo. Vamos a ver un ejemplo. Imagina que tienes el siguiente código:
sample :loop_garzul
16.times do
sample :bd_haus
sleep 0.5
endSi quieres añadir el efecto al sample :loop_garzul, sólo necesitas meter el bucle en un bloque with_fx, así:
with_fx :flanger do
sample :loop_garzul
end
16.times do
sample :bd_haus
sleep 0.5
endVale, y ahora si quieres añadir el efecto al pedal de la batería, vas y lo envuelves con with_fx, exactamente igual:
with_fx :flanger do
sample :loop_garzul
end
with_fx :echo do
16.times do
sample :bd_haus
sleep 0.5
end
endRecuerda, puedes envolver cualquier código en with_fx y cualquier sonido que haya creado el código pasará por ese efecto.
Si estás buscando tu verdadero sonido al hacer código, pronto querrás saber cómo modificar y controlar sintetizadores y efectos. Por ejemplo, puede que quieras cambiar la duración de una nota, añadir más reverberación, o cambiar el tiempo entre ecos. Por suerte, Sonic Pi te da un nivel de control increíble para hacer esto, con unas cosas especiales llamadas parámetros u opciones (abreviado como opts). Copia este código en tu área de trabajo y dale a Ejecutar:
sample :guit_em9¡Hey, un sonido de guitarra! Vamos a jugar un poco con ese sonido. ¿Qué te parece si cambiamos su ritmo?
sample :guit_em9, rate: 0.5Ey, ¿qué es ese rate: 0.5 que acabo de añadir al final? Eso se llama opción (opt). Todos los sintetizadores y efectos de Sonic Pi soportan los opt’s, y hay montones con los que puedes trastear. También están disponibles para efectos. Prueba esto:
with_fx :flanger, feedback: 0.6 do
sample :guit_em9
endAhora, ¡prueba a subir la retroalimentación (feedback) a 1, para escuchar sonidos muuy locos! Lee la documentación para más detalles sobre los muchos opts que tienes disponibles.
La mejor forma de experimentar rápido y explorar Sonic Pi es hacer código en vivo (live coding). Esto te permite empezar con algo de código e ir cambiándolo continuamente, retocándolo mientras suena. Por ejemplo, si no sabes qué le hace el parámetro cutoff a un sample, empieza a trastear con ello. ¡Vamos a probar! Copia este código en una de tus áreas de trabajo de Sonic Pi:
live_loop :experiment do
sample :loop_amen, cutoff: 70
sleep 1.75
endAhora, dale a Ejecutar y escucharás un break de batería ligeramente amortiguado. Vale, ahora cambia el valor de cutoff: a 80 y dale a Ejecutar de nuevo. ¿Escuchas la diferencia? Prueba con 90, 100, 110…
Una vez le has cogido el tranquillo a usar live_loops, verás no puedes dejar de usarlo. Cada vez que toco en un concierto de live coding, confío en mi live_loop igual que un/a baterista confía en sus baquetas. Para más información sobre live coding, mira la Sección 9 de el tutorial incluido en el programa.
Por último, algo que me encanta es hacer trampa dejando a Sonic Pi que componga cosas por mí. Una forma muy chula de hacer esto es usar randomización. Puede sonar complicado, pero en realidad no lo es. Vamos a echarle un vistazo. Copia esto en un área de trabajo vacía:
live_loop :rand_surfer do
use_synth :dsaw
notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
16.times do
play notes.choose, release: 0.1, cutoff: rrand(70, 120)
sleep 0.125
end
endAhora, cuando toques esto, escucharás un flujo constante de notas aleatorias de la escala :e2 :minor_pentatonic, tocada con el sintetizador :dsaw. “¡Espera, espera! Eso no es una melodía”, te oigo decir entre gritos. Pues bien, aquí viene la primera parte del truco de magia. Cada vez que damos una vuelta en el live_loop, le podemos decir a Sonic Pi que resetee el flujo aleatorio a un punto que conozcamos. Vamos a probarlo - añade la línea use_random_seed_1 al live_loop:
live_loop :rand_surfer do
use_random_seed 1
use_synth :dsaw
notes = (scale :e2, :minor_pentatonic, num_octaves: 2)
16.times do
play notes.choose, release: 0.1, cutoff: rrand(70, 120)
sleep 0.125
end
endAhora, cada vez que el live_loop da una vuelta, el flujo de notas aleatorias se resetea. Esto significa que elige las mismas 16 notas cada vez. ¡Abracadabra! Una melodía en el momento. Aquí viene la parte realmente interesante. Cambia el valor de la semilla de 1 a cualquier otro número. Por ejemplo, 4923. ¡Guau! ¡Otra melodía! O sea, con cambiar un sólo número (la semilla), ¡puedes explorar tantas combinaciones melódicas que te puedas imaginar! He aquí la magia del código.
El rayo láser atravesaba las nubes de humo; el subwoofer bombeaba las notas graves muy profundamente, en los cuerpos del público. El ambiente estaba cargado con una embriagadora mezcla de sintetizadores y baile. Sin embargo, algo no llegaba a encajar del todo en esta discoteca. Proyectado en colores brillantes, encima de la cabina de DJ, había un texto moviéndose, bailando, relampagueante. No eran efectos visuales, sino una simple proyección de Sonic Pi ejecutándose en una Raspberri Pi. La persona que estaba en la cabina de DJ no estaba tocando discos; estaba escribiendo, editando y evaluando código. En vivo. Esto es Live Coding.
Esto puede sonar como la disparatada historia de una discoteca futurista, pero escribie música en código como en esta historia es una tendencia cada vez más extendida, y se suele llamar por el nombre de Live Coding (http://toplap.org). Una de las direcciones más recientes que este estilo ha tomado es el Algorave (http://algorave.com) - eventos en los que l@s artistas como yo programamos música para que la gente baile. No obstante, no tienes por qué estar en una discoteca para hacer Live Coding - con Sonic Pi versión 2.6 (y posteriores), puedes hacerlo siempre que tengas a mano tu Raspberry Pi y un par de auriculares o unos altavoces. Una vez llegues al final de este artículo, programarás tus propios beats y sabrás modificarlos en vivo y en directo. A dónde llegues después de esto está en el poder de tu imaginación.
La clave para hacer live coding con Sonic Pi está en manejar el live_loop (bucle en vivo). Vamos a ver uno:
live_loop :beats do
sample :bd_haus
sleep 0.5
endUn live_loop tiene 4 ingredientes fundamentales. El primero es su nombre. Nuestro live_loop de arriba se llama :beats. Eres libre de llamar a tu live_loop como quieras. Haz una locura. Sé creativ@. Yo suelo usar nombres que comuniquen algo sobre la música que va a sonar, pensando en el público. El segundo ingrediente es la palabra do que marca dónde empieza el live_loop. El tercer ingrediente es la palabra end que marca dónde el live_loop acaba, y finalmente está el cuerpo del live_loop que describe qué es lo que va a repetir el bucle (ésta es la parte entre el do y el end). En este caso estamos tocando de forma repetida un bombo de batería y luego esperamos durante medio pulso. Esto produce un pulso grave regular perfecto. Adelante, cópialo en un búfer vacío de Sonic Pi y dale a Ejecutar. ¡Boom, Boom, Boom!.
Vale, entonces, ¿qué hace al live_loop tan especial? ¡Hasta ahora parecía un loop glorificado! Pues bien, la belleza de los live_loops está en que puedes redefinirlos sobre la marcha, al vuelo. Esto significa que mientras que éstos se ejecutan, puedes cambiar lo que hacen. Éste es el secreto de hacer live coding con Sonic Pi. Vamos a tocar un poco:
live_loop :choral_drone do
sample :ambi_choir, rate: 0.4
sleep 1
endAhora pulsa el botón de Ejecutar o presiona las teclas alt-r. Ahora mismo estás escuchando unos coros preciosos. Ahora, mientras suenan, cambia el rate de 0.4 a 0.38. Dale a Ejecutar de nuevo. ¡Guau! ¿Notas cómo ha cambiado la nota del coro? Cámbialo de nuevo a 0.4 para volver a cómo era antes. Ahora bájalo a 0.2, luego a 0.19 y después vuelve a 0.4. ¿Ves cómo el cambiar un sólo parámetro sobre la marcha, te puede dar control de verdad sobre la música? Ahora trastea con el rate tú mism@ - escoge tus propios valores. Prueba con números neativos, números muy pequeños y números muy grandes. ¡Que te diviertas!
Una de las lecciones más importantes sobre el live_loop es que necesitan descansar. Mira el siguiente live_loop:
live_loop :infinite_impossibilities do
sample :ambi_choir
endSi intentas ejecutar este código, verás de inmediato a Sonic Pi quejándose de que el live_loop no durmió. ¡Esto es el sistema de seguridad haciendo efecto! Tómate un segundo para pensar en lo que este código le está pidiendo al ordenador que haga. Efectivamente, le está pidiendo al ordenador que toque un número infinito de samples de coro en cero segundos. De no ser por el sistema de seguridad, el pobre ordenador intentará hacerlo y se colgará y arderá en el proceso. Así que recuerda, tu live_loop debe contener un sleep.
La música está llena de cosas pasando a la vez. La batería a la vez que el bajo a la vez que las voces a la vez que las guitarras… En informática llamamos a esto concurrencia, y Sonic Pi nos ofrece una forma increíblemente fácil de tocar varias cosas a la vez. Sencillamente, ¡usa más de un live_loop!
live_loop :beats do
sample :bd_tek
with_fx :echo, phase: 0.125, mix: 0.4 do
sample :drum_cymbal_soft, sustain: 0, release: 0.1
sleep 0.5
end
end
live_loop :bass do
use_synth :tb303
synth :tb303, note: :e1, release: 4, cutoff: 120, cutoff_attack: 1
sleep 4
endAquí tenemos dos live_loops, uno dando la vuelta rápido marcando el pulso, y otro dando la vuelta lentamente y tocando un sonido de bajo muy loco.
Una de las cosas interesantes que tiene el usar varios live_loops es que cada uno gestiona su propio tiempo. Esto significa que es muy fácil crear estructuras polirrítimicas interesantes, e incluso tocar con fases al estilo de Steve Reich. Échale un ojo a esto:
# Steve Reich's Piano Phase
notes = (ring :E4, :Fs4, :B4, :Cs5, :D5, :Fs4, :E4, :Cs5, :B4, :Fs4, :D5, :Cs5)
live_loop :slow do
play notes.tick, release: 0.1
sleep 0.3
end
live_loop :faster do
play notes.tick, release: 0.1
sleep 0.295
endEn cada uno de estos tutoriales, vamos a acabar con un ejemplo final en forma de una pieza de música, que coge un poco de todas las ideas que hemos ido introduciendo. Lee este código y mira si puedes imaginarte lo que está haciendo. Después, cópialo en un búfer vacío en Sonic Pi, dale a Ejecutar y escucha cómo suena. Finalmente, cambia uno de los números o comenta y descomenta cosas. Mira si puedes utilizar esto como un punto de partida para una nueva actuación, y sobre todo, ¡para pasártelo bien! Hasta la próxima…
with_fx :reverb, room: 1 do
live_loop :time do
synth :prophet, release: 8, note: :e1, cutoff: 90, amp: 3
sleep 8
end
end
live_loop :machine do
sample :loop_garzul, rate: 0.5, finish: 0.25
sample :loop_industrial, beat_stretch: 4, amp: 1
sleep 4
end
live_loop :kik do
sample :bd_haus, amp: 2
sleep 0.5
end
with_fx :echo do
live_loop :vortex do
# use_random_seed 800
notes = (scale :e3, :minor_pentatonic, num_octaves: 3)
16.times do
play notes.choose, release: 0.1, amp: 1.5
sleep 0.125
end
end
endUno de los desarrollos tecnológicos más emocionantes y disruptivos en la música moderna fue la invención de los samplers. Eran cajas que te permitían grabar cualquier sonido y manipularlo, reproduciendo estos sonidos grabados de distintas formas muy interesantes. Por ejemplo, podías coger una grabación antigua, encontrar un solo de batería (o un break), grabarlo en tu sampler y después reproducirlo en repetición a la mitad de la velocidad, para tener una base para tus beats. Así es como la música hip-hop se creó en sus inicios; hoy en día es casi imposible encontrar música electrónica que no incorpore samples de algún tipo. Usar samples es una forma maravillosa de introducir fácilmente elementos nuevos e interesantes en tus conciertos de live coding.
¿Y dónde puedes conseguir un sampler? Bueno, ya tienes uno - ¡es tu Raspberry Pi! La aplicación incorporada Sonic Pi incluye un sampler extremadamente potente. ¡Vamos a tocar con él!
Uno de los samples de batería más clásicos y reconocibles es el Amen Break. Fue utilizado por primera vez en 1969 en la canción “Amen Brother”, de los Winstons, como parte de un break de batería. Sin embargo, no fue conocido hasta que lo descubrieron los primeros músicos de hip-hop de los 80’s, quienes lo usaron en samplers; a partir de ahí empezó a usarse muchísimo, y en una gran variedad de estilos como drum and bass, breakbeat, hardcore tecno y breakcore.
Te encantará saber que este sample también está incorporado en Sonic Pi. Limpia un búfer y pega este código:
sample :loop_amenDale a Ejecutar y ¡boom! Estás escuchando uno de los breaks de batería más importante de la historia de la música dance. No obstante, este sample no era famoso por ser tocado una vez; estaba pensado para ser tocado en bucle.
Vamos a poner el Amen Break en bucle usando nuestro viejo amigo, el live_loop introducido en este tutorial el último mes:
live_loop :amen_break do
sample :loop_amen
sleep 2
endVale, está en bucle, pero a cada vuelta se escucha una molesta pausa. Esto pasa porque le dijimos que durmiese 2 pulsos; con el BPM por defecto de 60 que tiene el sample :loop_amen, éste sólo dura 1.753 pulsos. Por eso ponemos un silencio de 2 - 1.753 = 0.247 pulsos. Aunque es un silencio corto, se nota.
Para arreglar este problema, podemos usar el opt beat_stretch: para decirle a Sonic Pi que estire (stretch) o encoja (shrink) el sample, de modo que éste encaje con el número de beats que queremos.
Las funciones sample y synth en Sonic Pi te dan mucho control con parámetros opcionales, como amp:, cutoff: y release:. Lo de parámetro opcional suena un poco a trabalenguas, así que vamos a llamarlos opts (del inglés option, opción) para que sea más fácil.
live_loop :amen_break do
sample :loop_amen, beat_stretch: 2
sleep 2
end ¡Ahora sí se puede bailar! Tal vez queramos hacerlo más rápido o más lento, para que encaje con el carácter del baile.
Bueno, ¿y qué pasa si queremos cambiar el estilo a hip hop de la vieja escuela, o a breakcore? Una forma fácil de hacer esto es jugar con el tiempo - o en otras palabras, toquetear el tempo de la canción. Esto es súper fácil en Sonic Pi - sólo necesitas poner un use_bpm en tu live loop:
live_loop :amen_break do
use_bpm 30
sample :loop_amen, beat_stretch: 2
sleep 2
end Mientras rapeas con esos beats lentos, fíjate en que seguimos durmiendo 2 y que nuestro BPM es 30, y aun así todo sigue a tiempo. El opt beat_stretch trabaja con el BPM actual para asegurarse de que todo suene bien.
Aquí viene la parte graciosa. Mientras el bucle sigue activo, cambia el 30 a 50 en la línea de use_bpm 30. ¡Guau, todo ha acelerado, pero sigue a tiempo! Intenta ir más rápido - a 80, a 120, ¡y ahora vuélvete loc@ y mete 200!
Ahora que podemos poner samples en bucle en directo, vamos a ver uno de los opts más divertidos del sintetizador sample. El primero es cutoff:, que controla el filtro limitador (cutoff) del sampler. Está desactivado por defecto, pero puedes activarlo fácilmente:
live_loop :amen_break do
use_bpm 50
sample :loop_amen, beat_stretch: 2, cutoff: 70
sleep 2
end Adelante, cambia el opt cutoff. Por ejemplo, súbelo a 100, dale a Ejecutar y espera al bucle que dé una vuelta para escuchar el cambio en el sonido. Fíjate en que valores bajos como 50 suenan suaves, como un bajo; valores altos como 100 o 120 son más completos y ásperos. Esto pasa porque la opción cutoff: corta las frecuencias altas del sonido, igual que un cortacésped corta la parte de arrriba de la hierba. La opción cutoff: es como la longitud del cortacésped: determina cuánta hierba deja sin cortar.
Otra herramienta muy chula que puedes probar es el efecto de corte (slicer). Éste corta (slice) el sonido. Envuelve la línea que dice sample con el código del efecto, tal que así:
live_loop :amen_break do
use_bpm 50
with_fx :slicer, phase: 0.25, wave: 0, mix: 1 do
sample :loop_amen, beat_stretch: 2, cutoff: 100
end
sleep 2
endSi te das cuenta, el sonido se balancea hacia arriba y hacia abajo un poco más. (Puedes escuchar el sonido original sin el efecto cambiando el opt mix: a 0). Ahora, experimenta con la opción phase:. Este controla el ritmo (en pulsos) del efecto de slicing. Un valor más pequeño como 0.125 corta más rápido, y valores grandes como 0.5 cortan más lento. Fíjate en que si doblas o divides por la mitad la opción phase: sucesivamente, siempre suena bien. Por último, cambia la opción wave: a 0, 1 o 2, y escucha cómo cambia el sonido. Éstos números son distintas formas de onda. 0 es una onda de sierra (inicio duro, salida suave), 1 es una onda cuadrada (inicio duro, salida dura), y 2 es una onda de triángulo (inicio suave, salida suave).
Por último, vamos a volver atrás en el tiempo y a visitar de nuevo la escena drum and bass de Bristol en sus inicios, con el ejemplo de este mes. No te preocupes si no lo entiendes; tú escríbelo, dale a Ejecutar, y empieza a hacer live coding cambiando los números de los opts, a ver a dónde puedes llegar con ello. Por favor, ¡comparte tus creaciones! Hasta la próxima…
use_bpm 100
live_loop :amen_break do
p = [0.125, 0.25, 0.5].choose
with_fx :slicer, phase: p, wave: 0, mix: rrand(0.7, 1) do
r = [1, 1, 1, -1].choose
sample :loop_amen, beat_stretch: 2, rate: r, amp: 2
end
sleep 2
end
live_loop :bass_drum do
sample :bd_haus, cutoff: 70, amp: 1.5
sleep 0.5
end
live_loop :landing do
bass_line = (knit :e1, 3, [:c1, :c2].choose, 1)
with_fx :slicer, phase: [0.25, 0.5].choose, invert_wave: 1, wave: 0 do
s = synth :square, note: bass_line.tick, sustain: 4, cutoff: 60
control s, cutoff_slide: 4, cutoff: 120
end
sleep 4
endNo importa si es el giro hechizante de los estrepitosos osciladores, o el golpe desafinado de las ondas de sierra perforando el remix; el sintetizador que lleva la melodía (lead synth) tiene un papel muy importante en cualquier canción de música electrónica. En la edición del último mes de esta serie de tutoriales, vimos cómo programar nuestros beats. En este tutorial, vamos a ver cómo programar los tres componentes fundamentales de un buen riff de sintetizador - timbre, melodía y ritmo.
Vale, pues enciende tu Raspberry Pi, abre Sonic Pi v2.6+ y, ¡vamos a hacer ruido!
Una parte esencial de cualquier riff de sintetizador es cambiar y jugar con el timbre de los sonidos. Podemos controlar el timbre en Sonic Pi de dos formas - eligiendo diferentes sintetizadores para un cambio drástico, y cambiando los opts de un mismo sintetizador para un cambio más suave. También podemos usar efectos, pero eso lo veremos en otro tutorial…
Vamos a crear un live loop sencillo, donde podamos cambiar constantemente el sintetizador actual:
live_loop :timbre do
use_synth (ring :tb303, :blade, :prophet, :saw, :beep, :tri).tick
play :e2, attack: 0, release: 0.5, cutoff: 100
sleep 0.5
endÉchale un vistazo al código. Sólo estamos haciendo ticking sobre un anillo de nombres de sintetizador (esto recorre cada uno de ellos y repite la lista una y otra vez). Le pasamos este nombre de sintetizador a la función (abreviada como fn) use_synth, que cambia el sintetizador actual del live_loop. También estamos tocando la nota :e2 (Mi en la segunda octava), con una separación de 0.5 pulsos (medio segundo con el BPM de 60 que está por defecto), y con la opción cutoff: puesta a 100.
Escucha cómo los distintos sintetizadores tienen sonidos muy diferentes, aunque estén tocando la misma nota. Ahora, experimenta y juega con ello. Cambia el tiempo de decaimiento (release) a valores más altos y más bajos. Por ejemplo, cambia las opciones attack: y release: para ver cómo distintos tiempos de entrada y salida pueden cambiar considerablemente el sonido. Finalmente, cambia el opt cutoff: para ver cómo distintos valores de cutoff pueden cambiar notablemente el timbre (con valores entre 60 y 130 está bien). Mira cuántos sonidos distintos puedes crear con sólo cambiar unos pocos valores. Una vez le cojas el tranquillo, ve a la pestaña de Sintetizadores en el sistema de Ayuda si quieres una lista completa de todos los sintetizadores y de todas las opciones disponibles para cada sintetizador, para que veas cuánto poder tienes en tus manos de programador/a.
Timbre es una palabra guay para describir cómo suena un sonido. Si tocas la misma nota con distintos instrumentos como un violín, una guitarra o un piano, la altura (cómo de agudo o grave suena) es la misma en todos ellos, pero la cualidad del sonido cambia. Esa cualidad del sonido - aquello que te permite diferenciar un piano de una guitarra, es el timbre.
Otro aspecto importante para nuestro sintetizador lead son las notas que queremos que toque. Si ya tienes una idea, sólo tienes que crear un anillo con las notas que has pensado, y hacer ticking sobre ellas:
live_loop :riff do
use_synth :prophet
riff = (ring :e3, :e3, :r, :g3, :r, :r, :r, :a3)
play riff.tick, release: 0.5, cutoff: 80
sleep 0.25
endAquí hemos definido nuestra melodía con un anillo, que incluye notas como :e3 y silencios representados como un ‘:r’. Después usamos .tick para recorrer cada nota, lo que nos da un riff repetitivo.
No siempre es fácil inventarse una melodía desde cero. Es más fácil pedirle a Sonic Pi una selección de riffs aleatorios y esocoger aquel que te guste más. Para ello tenemos que combinar tres cosas: anillos, aleatoriedad y semillas aleatorias. Veamos un ejemplo:
live_loop :random_riff do
use_synth :dsaw
use_random_seed 3
notes = (scale :e3, :minor_pentatonic).shuffle
play notes.tick, release: 0.25, cutoff: 80
sleep 0.25
endHay varias cosas que tenemos que revisar - vamos a verlas una por una. Primero, estamos usando una semilla aleatoria de 3. ¿Qué significa esto? Bien, hacer esto es muy útil porque, cuando especificamos la semilla, podemos predecir cuál va a ser el siguiente valor aleatorio - ¡igual que la última vez que pusimos la semilla a 3! Otra cosa útil que te viene bien saber, es que desordenar un anillo de notas funciona de la misma forma. En el ejemplo de arriba estamos preguntando por el ‘tercer desorden’ en la lista estándar de formas de desordenar notas - que también es igual cada vez porque siempre estamos usando la misma semilla para el mismo valor, justo antes de que empecemos a desordenar las notas. Finalmente, estamos haciendo ticking, recorriendo nuestras notas desordenadas para tocar el riff.
Ahora es cuando empieza la diversión. Si cambiamos el valor de la semilla aleatoria a otro número, como 3000, obtenemos una mezcla de notas totalmente distinta. Así es muy fácil explorar nuevas melodías. Sencillamente, escoge la lista de notas que queremos mezclar (una escala está bien para empezar), y selecciona la semilla con la que queremos mezclarlas. Si no te gusta la melodía, sólo tienes que cambiar las notas o la semilla, y probar de nuevo. ¡Repite hasta que te guste lo que escuchas!
La aleatoriedad en Sonic Pi no es aleatoria en realidad; es lo que se conoce como pseudoaleatoria. Imagina que tienes que tirar un dado 100 veces y luego escribes los resultados en una hoja de papel. Sonic Pi tiene algo parecido esta lista de resultados, que utiliza cuando le pides un valor aleatorio. Ajustar la semilla aleatoria es como saltar a un punto específico en dicha lista.
Otro aspecto importante de nuestro riff es el ritmo - cuándo tocar una nota y cuándo no. Como vimos arriba, podemos usar :r en nuestros anillos para insertar silencios. Otra forma muy potente de hacer esto es usar extensiones (spreads), que veremos en otro tutorial. Hoy vamos a usar la aleatoriedad para que nos ayude a encontrar nuestro ritmo. En vez de tocar cada nota, vamos a usar una condición para tocar una nota con una determinada probabilidad. Vamos a echarle un vistazo:
live_loop :random_riff do
use_synth :dsaw
use_random_seed 30
notes = (scale :e3, :minor_pentatonic).shuffle
16.times do
play notes.tick, release: 0.2, cutoff: 90 if one_in(2)
sleep 0.125
end
endUna función muy útil que deberías conocer es one_in, que nos devuelve un valor true (verdadero) o false (falso) con una determinada probabilidad. Vamos a usar un valor de 2, así que, de media, una de cada dos llamadas a one_in va a devolver true. Dicho de otra forma, el 50% del tiempo vamos a recibir true. Usar valores más altos devolverá false más a menudo, introduciendo más espacio en el riff.
Fíjate en que hemos añadido algo de iteración con el 16.times. Esto es porque sólo queremos resetear el valor de nuestra semilla aleatoria cada 16 notas, de modo que nuestro ritmo se repita cada 16 veces. Esto no afecta a la mezcla, ya que dicha operación se realiza justo después de que se ajuste la semilla. Podemos usar el tamaño de la iteración para cambiar la duración del riff. Prueba a cambiar el 16 a 8, o incluso a 4 o 3, y mira cómo afecta al ritmo del riff.
Vale, ahora vamos a combinar todo lo que hemos aprendido en un ejemplo final. ¡Hasta la próxima!
live_loop :random_riff do
# uncomment to bring in:
# synth :blade, note: :e4, release: 4, cutoff: 100, amp: 1.5
use_synth :dsaw
use_random_seed 43
notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle.take(8)
8.times do
play notes.tick, release: rand(0.5), cutoff: rrand(60, 130) if one_in(2)
sleep 0.125
end
end
live_loop :drums do
use_random_seed 500
16.times do
sample :bd_haus, rate: 2, cutoff: 110 if rand < 0.35
sleep 0.125
end
end
live_loop :bd do
sample :bd_haus, cutoff: 100, amp: 3
sleep 0.5
endEs imposible mirar en la historia de la música electrónica dance sin ver el enorme impacto del pequeño sintetizdor Roland TB-303. Es la salsa secreta del sonido de bajo ácido (acid bass). Esos clásicos riffs de bajo chillones del TB-303 se pueden escuchar desde los inicios de la música House en Chicago, hasta en artistas electrónic@s más recientes como Plastikman, Squarepusher y Aphex Twin.
Curiosamente, Roland no diseñó el TB-303 para música de baile. Se creó inicialmente como una ayuda para practicar para guitarristas. Pensaron que la gente podría programarlos para tocar líneas de bajo eléctrico que sirviesen de acompañamiento. Por desgracia había varios problemas: eran un poco difíciles de programar, no sonaban muy bien como substitutos para un bajo eléctrico, y eran bastante caros. Para contrarrestar sus pérdidas, Roland dejó de fabricarlos después de vender 10.000 unidades, y después de unos años cogiendo polvo en armarios de guitarristas, era fácil verlos en los escaparates de tiendas de segunda mano. Estos TB-303 solitarios estaban esperando a ser descubiertos por una nueva generación de experimentador@s que empezaron a usarlos de formas en las que Roland no se habría imaginado, creando sonidos muy guays. Así nació el Acid House.
Aunque no es fácil tocar un TB-303 original, te alegrará saber que puedes convertir tu Raspberri Pi en este sintetizador usando el poder de Sonic Pi. Abre Sonic Pi, pon este código en un búfer vacío, dale a Ejecutar y contempla…:
use_synth :tb303
play :e1¡Acid bass al instante! Vamos a cambiar cosillas…
Primero, vamos a construir un arpegiador en directo para hacer las cosas más divertidas. En el último tutorial vimos cómo un riff puede ser sencillamente un anillo de notas sobre las que hacemos tick una tras otra, repitiéndolas cuando llegamos al final. Vamos a crear un live loop que haga justo eso:
use_synth :tb303
live_loop :squelch do
n = (ring :e1, :e2, :e3).tick
play n, release: 0.125, cutoff: 100, res: 0.8, wave: 0
sleep 0.125
endÉchale un vistazo a cada línea.
En la primera línea ponemos el sintetizador por defecto como tb303, con la función use_synth.
En la línea dos creamos un live loop llamado :squelch (chillar) que sencillamente da vueltas, vueltas y más vueltas.
En la línea tres es donde creamos nuestro riff - un anillo de notas (Mi en las octavas 1, 2 y 3), que recorremos con .tick. Definimos n para representar la nota actual dentro del riff. El símbolo de igual asigna el valor de la derecha al nombre de la izquierda. Este valor será diferente en cada vuelta del bucle. La primera vez, n valdrá :e1. La segunda vez valdrá :e2, luego :e3, y así hasta volver a :e1, dando vueltas para siempre.
En la línea cuatro es donde realmente usamos nuestro sintetizador :tb303. Le estamos pasando varios opts interesantes: release:, cutoff:, res: y wave:, que vamos a ver a continuación.
La línea cinco es nuestro sleep - le estamos diciendo al live loop que dé una vuelta cada 0.125, o 8 veces cada segundo si utilizamos el BPM por defecto (60).
La línea séis es el end (fin) de nuestro live loop. Esto le dice a Sonic Pi dónde acaba el live loop, sencillamente.
Mientras te preguntas qué está pasando, escribe el código de arriba en Sonic Pi y dale a Ejecutar. Deberías escuchar el :tb303 en acción. Ahora viene lo bueno: vamos a hacer live coding.
Mientras el bucle sigue funcionando, cambia el opt cutoff: a 110. Ahora dale al botón de Ejecutar de nuevo. Deberías escuchar que el sonido se hace un poco más duro y chillón. Cambia de nuevo el cutoff: a 120 y dale a Ejecutar. Ahora con 130. Escucha cómo frecuencias de cutoff más bajas hacen que suene más penetrante e intenso. Finalmente, bájalo a 80, con lo que sentirás una sensación de respiro. Repite tantas veces como quieras. No te preocupes, yo sigo por aquí…
Otra opción que merece la pena probar es res:. Ésta controla el nivel de resonancia del filtro. Una resonancia alta es típica de sonidos de acid bass. Ahora mismo tenemos nuestro res: a 0.8. Prueba a cambiarlo a 0.85, luego a 0.9, y finalmente a 0.95. Tal vez notes que un cutoff como 110 o más alto hace las diferencias más fáciles de escuchar. Ahora haz una locura y cámbialo a 0.999 para escuchar sonidos muy chulos. ¡Con una res tan alta, escuchas el filtro cutoff resonando tanto que empieza a crear sonidos él mismo!
Por último, para un cambio grande en el timbre, modifica el valor de la opción wave a 1. Esta opción selecciona un oscilador inicial. El valor por defecto es 0, que es una onda de sierra. 1 es una onda de pulso y 2 es una onda triangular.
Por supuesto, prueba con distintos riffs cambiando las notas en el anillo o incluso cogiendo notas de escalas o acordes. Que te diviertas con tu primer sintetizador de acid bass.
El diseño del TB-303 original es muy sencillo en realidad. Como puedes ver en el siguiente diagrama, sólo tiene 4 partes básicas.
En primer lugar tenemos la onda de oscilador - el ingrediente crudo del sonido. En este caso tenemos una onda cuadrada. Después tenemos el envolvente (envelope) de amplitud del oscilador, que controla la amplificación (amp) de la onda cuadrada con el paso del tiempo. Estas opciones se acceden en Sonic Pi con los opts attack:, decay:, sustain: y release:, y lo mismo con sus versiones para el volumen. Para más información, lee la sección 2.4, ‘Duración con Envolventes’ en el tutorial incluido en Sonic Pi. Después del envolvente pasamos nuestra onda cuadrada por un filtro de paso bajo. Aquí es donde empieza la diversión. ¡El valor de cutoff de este filtro también se controla con su propio envolvente! Esto significa que tenemos un nivel de control alucinante sobre el tumbre del sonido con sólo jugar con estos dos envolventes. Echémosle un vistazo:
use_synth :tb303
with_fx :reverb, room: 1 do
live_loop :space_scanner do
play :e1, cutoff: 100, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
sleep 8
end
endPara cada opción estándar de un envolvente, hay una opción cutoff_ equivalente en el sintetizador :tb303. Por tanto, podemos usar la opción cutoff_attack: para cambiar el valor de ataque del cutoff. Copia el código de abajo en un búfer vacío y dale a Ejecutar. Escucharás un sonido de lo más curioso, haciendo trinos arriba y abajo. Ahora empieza a tocar cosillas. Prueba a cambiar el tiempo de cutoff_attack a 1, y luego a 0.5. Ahora prueba con 8.
Fíjate en que he pasado todo por un efecto :reverb para darle un poco más de ambiente - ¡prueba con otros efectos para ver cuál funciona mejor!
Finalmente, aquí tienes una pieza que he compuesto usando ideas de este tutorial. Cópiala en un búfer vacío, escúchala un rato y empieza a a hacer live coding con tus propios cambios. ¡A ver qué sonidos locos le puedes sacar! Hasta la próxima…
use_synth :tb303
use_debug false
with_fx :reverb, room: 0.8 do
live_loop :space_scanner do
with_fx :slicer, phase: 0.25, amp: 1.5 do
co = (line 70, 130, steps: 8).tick
play :e1, cutoff: co, release: 7, attack: 1, cutoff_attack: 4, cutoff_release: 4
sleep 8
end
end
live_loop :squelch do
use_random_seed 3000
16.times do
n = (ring :e1, :e2, :e3).tick
play n, release: 0.125, cutoff: rrand(70, 130), res: 0.9, wave: 1, amp: 0.8
sleep 0.125
end
end
end¡Hola y bienvenid@ de nuevo! En tutoriales anteriores, nos hemos centrado sólamente en las posibilidades musicales de Sonic Pi - (convirtiendo tu Raspberry Pi en un instrumento musical preparado para tu concierto). Hasta ahora hemos aprendido cómo:
Hacer Live Coding - cambiar sonidos al vuelo, Programar unos beats muy salvajes, Generar sintetizadores lead potentes, Re-crear el famoso sonido acid bass del TB-303.
Hay mucho más por ver (que exploraremos en futuras ediciones). Sin embargo, este mes vamos a centrarnos en algo que Sonic Pi hace y que de lo que probablemente no te has dado cuenta: controlar Minecraft.
Vale, allá vamos. Enciende tu Raspberry Pi, abre Minecraft Pi y crea un nuevo mundo. Ahora inicia Sonic Pi, y mueve y cambia el tamaño de ambas ventanas, para que puedas ver Sonic Pi y Minecraft Pi al mismo tiempo.
Escribe lo siguiente en un búfer vacío:
mc_message "Hola Minecraft desde Sonic Pi!"Ahora, dale a Ejecutar. ¡Boom! ¡Tu mensaje apareció en Minecraft! ¿A que ha sido fácil? Ahora, deja de leer esto por un momento y prueba a poner tus propios mensajes. ¡Que te diviertas!
Ahora vamos a explorar el mundo. La opción estándar es coger el teclado y el ratón y empezar a moverte alrededor. Esto funciona, pero es bastante lento y aburrido. Sería mucho mejor si tuviésemos una especie de máquina de teletransporte. Bueno, tenemos una, gracias a Sonic Pi. Prueba esto:
mc_teleport 80, 40, 100¡Vaya! Eso ha sido una subida. Si no estuvieses en modo vuelo habrías caído toda esa distancia hasta el suelo. Si pulsas dos veces la tecla espacio para entrar en el modo vuelo y teletransportarte de nuevo, te quedarás flotando en el lugar al que has volado a toda pastilla.
¿Y qué significan esos números? Tenemos tres números que indican las coordenadas del lugar del mundo donde te encuentras. Le damos un nombre a cada número: x, y, z:
x - cómo de lejos estás a la derecha o a la izquierda (80 en nuestro ejemplo) y - cómo de alto queremos estar (40 en nuestro ejemplo) z - cómo de lejos hacia delante o hacia atrás (100 en nuestro ejemplo)
Al escoger distintos valores de x, y y z, podemos teletransportarnos a cualquier lugar en nuestro mundo. ¡Pruébalo! Escoge distintos números y mira dónde puedes acabar. Si la pantalla se vuelve negra es porque te has teletransportado debajo del suelo o dentro de una montaña. Sencillamente pon un valor más alto de y, para volver a estar por encima de la tierra. Sigue explorando hasta que encuentres algo que te guste…
Usando estas ideas, vamos a construir un Teletransportador Sonoro que haga un sonido de teletransporte divertido mientras nos hace pasar zumbando por el mundo de Minecraft:
mc_message "Preparing to teleport...."
sample :ambi_lunar_land, rate: -1
sleep 1
mc_message "3"
sleep 1
mc_message "2"
sleep 1
mc_message "1"
sleep 1
mc_teleport 90, 20, 10
mc_message "Whoooosh!"
Ahora que has encontrado un sitio que te guste, ¡empecemos a construir!. Podrías hacer lo que sueles hacer y empezar a hacer click con el ratón una y otra vez (furiosamente) para poner bloques debajo del cursor. O podrías usar la magia de Sonic Pi. Prueba esto:
x, y, z = mc_location
mc_set_block :melon, x, y + 5, z¿Lo ves? ¡Hay un melón en el cielo! Tómate un momento para mirar el código. ¿Qué hemos hecho? En la línea uno, hemos cogido nuestra localización actual de Steve con las variables x, y, z. Éstas corresponden a nuestras coordenadas descritas anteriormente. Usamos esas coordenadas en la función mc_set_block, que deja el bloque que queramos en las coordenadas especificadas. Para hacer algo más alto en el cielo, sólo tenemos que subir el valor de y, que es el motivo por el cual le hemos añadido 5. Vamos a hacer una tira de melones:
live_loop :melon_trail do
x, y, z = mc_location
mc_set_block :melon, x, y-1, z
sleep 0.125
endAhora, vuelve a Minecraft, asegúrate de que estás en modo vuelo (si no, pulsa la tecla espacio dos veces), y vuelva por el mundo. Mira detrás tuya para ver… ¡una preciosa tira de bloques de melón! A ver qué patrones puedes hacer en el cielo.
Aquell@s que hayáis seguido este tutorial durante los últimos meses estaréis flipando en colores. La tira de melones está muy chula, pero la parte más increíble de este ejemplo es que ¡podéis usar live_loop con Minecraft! Para quienes no lo sepáis, live_loop es una habilidad mágica de Sonic Pi que no tiene ningún otro lenguaje de programación. Te permite ejecutar varios bucles al mismo tiempo y cambiarlos mientras tanto. Son increíblemente potentes y divertidos. Yo uso los live_loops para dar conciertos de música en discotecas con Sonic Pi - los DJs usan discos y yo uso live_loops :-) Sin embargo, hoy vamos a hacer live coding con música y con Minecraft.
Empecemos. Ejecuta el código de arriba y empieza a hacer tu propia tira de melones de nuevo. Ahora, sin parar el código, cambia :melon por :brick y dale a Ejecutar. ¡Abracadabra!, estás haciendo una tira de ladrillos. ¡A que es fácil! ¿Y si le ponemos música chula de fondo? Pan comido. Prueba esto:
live_loop :bass_trail do
tick
x, y, z = mc_location
b = (ring :melon, :brick, :glass).look
mc_set_block b, x, y -1, z
note = (ring :e1, :e2, :e3).look
use_synth :tb303
play note, release: 0.1, cutoff: 70
sleep 0.125
endAhora, mientras suena, empieza a cambiar el código. Cambia los tipos de bloques - prueba :water, :grass o tu tipo de bloque favorito. Prueba también a cambiar el valor de cutoff de 70 a 80 y así hasta 100. ¿Divertido, eh?
Vamos a combinar todo lo que hemos visto hasta ahora con un poco de magia extra. Vamos a combinar nuestra habilidad de teletransporte con moviminto de bloques y música, para crear un Videoclip de Minecraft. No te preocupes si no lo entiendes todo, tú dale y prueba a cambiar algunos valores mientras se ejecuta. Pásatelo bien y hasta la próxima…
live_loop :note_blocks do
mc_message "This is Sonic Minecraft"
with_fx :reverb do
with_fx :echo, phase: 0.125, reps: 32 do
tick
x = (range 30, 90, step: 0.1).look
y = 20
z = -10
mc_teleport x, y, z
ns = (scale :e3, :minor_pentatonic)
n = ns.shuffle.choose
bs = (knit :glass, 3, :sand, 1)
b = bs.look
synth :beep, note: n, release: 0.1
mc_set_block b, x+20, n-60+y, z+10
mc_set_block b, x+20, n-60+y, z-10
sleep 0.25
end
end
end
live_loop :beats do
sample :bd_haus, cutoff: 100
sleep 0.5
endTras nuestra pequeña excursión por el mundo fantástico de Minecraft programando con Sonic Pi este último mes, vamos a hacer música de nuevo. Hoy vamos a traer una pieza ópera clásica al siglo 21, usando el poder alucinante de la programación.
Viajemos atrás en el tiempo, al año 1875. Un compositor llamado Bizet ha acabado su última ópera, Carmen. Por desgracia, como ocurre con las piezas de música más disruptivas, no le gustó a la gente porque era demasiado expererimental y diferente. Tristemente, Bizet murió diez años antes de que la ópera se hiciese conocida internacionalmente y se convirtiese en una de las óperas más famosas y más tocadas de todos los tiempos. En un acto de simpatía con este genio y su tragedia, vamos a coger uno de los temas principales de Carmen y a convertirlo a un formato moderno de música que también es muy atroz y diferente para la mayoría de la gente de nuestra época - ¡la música con live coding!
Intentar hacer live coding con la ópera entera sería todo un desafío para este tutorial, así que vamos a centrarnos en una de las partes más conocidas - la línea de bajo de la Habanera:
Esto te puede parecer extremadamente ilegible si nunca has estudiado notación musical. No obstante, l@s programador@s vemos la notación musical como otra forma de código - sólo representa instrucciones para un/a músic@ en vez de un ordenador. Por tanto necesitamos encontrar una forma de descifrarlo.
Las notas están colocadas de izquierda a derecha como las palabras en esta revista, pero tienen distintas alturas. La altura en la partitura representa la altura de la nota. Cuanto más alta sea la nota en la partitura, mayor será la altura de la nota.
En Sonic Pi ya sabemos cómo cambiar la altura de una nota - usamos números más o menos altos como play 75 y play 80, o usamos los nombres de las notas: play :E y play :F. Por suerte, cada una de las posiciones verticales de la partitura representa el nombre de una nota específica. Échale un vistazo a esta tabla, es bastante útil:
Las partituras musicales son un tipo de código extremadamente rico y expresivo capaz de comunicar muchas cosas. Por tanto, no debería sorprenderte que las partituras no sólo te muestran cuándo tocar notas, sino también cuándo no tocarlas. En programación, esto es bastante parecido al concepto de nil o null - la ausencia de valor. En otras palabras, no tocar una nota es como la ausencia de una nota.
Si has mirado de cerca la partitura, verás que en realidad es una combinación de puntos negros, con líneas que representan las notas a tocar, y con cosas con forma de garrapata que representan silencios. Afortunadamente, Sonic Pi tiene una representación muy útil para el silencio: :r, así que si ejecutamos: play :r, en realidad, ¡está tocando silencio! También podríamos escribir play :rest, play nil o play false, que son formas equivalentes de representar silencios.
Finalmente, hay una última cosa que debemos aprender para descifrar la notación - los ritmos de las notas. En la notación original puedes ver que las notas están conectadas con líneas gruesas, llamadas barras. La segunda nota tiene dos de estas barras, que significa que dura la dieciseisava parte de un compás (lo que se llama beat en Sonic Pi). Las otras notas tienen una sola barra, que significa que duran la octava parte de un compás. El silencio tiene dos barras con forma de garrapata, que significa que también representa un dieciseisavo de un compás.
Cuando intentamos descifrar y explorar cosas nuevas, un truco muy útil es hacer todo lo más parecido posible, y buscar relaciones o patrones comunes. Por ejemplo, cuando reescribimos nuestra notación sólo con semicorcheas, vemos una secuencia muy sencilla de notas y silencios.
Ahora podemos empezar a traducir esta línea de bajo en Sonic Pi. Vamos a codificar estas notas y silencios en un anillo:
(ring :d, :r, :r, :a, :f5, :r, :a, :r)Veamos cómo suena. Ponlo en un live loop y haz tick sobre el mismo:
live_loop :habanera do
play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
sleep 0.25
end¡Fabuloso! La famosa melodía cobra vida a través de tus altavoces. Costó un poquitín llegar hasta aquí, pero ha merecido la pena - ¡choca los cinco!
Ahora que tenemos la línea de bajo, vamos a recrear parte de la atmósfera de esta escena de ópera. Un sintetizador que podríamos probar es :blade, que es un sintetizador lead con tono enfadado de los 80s. Vamos a probarlo con la nota inicial :d, que vamos a pasar por un slicer y un efecto de reverberación:
live_loop :habanera do
use_synth :fm
use_transpose -12
play (ring :d, :r, :r, :a, :f5, :r, :a, :r).tick
sleep 0.25
end
with_fx :reverb do
live_loop :space_light do
with_fx :slicer, phase: 0.25 do
synth :blade, note: :d, release: 8, cutoff: 100, amp: 2
end
sleep 8
end
endAhora, prueba con otras notas en la línea de bajo: :a y :f5. Recuerda, no tienes por qué parar, puedes modificar el código mientras suena la música y darle a Ejecutar de nuevo. Además, puedes probar distintos valores para el opt phase: del slicer, como 0.5, 0.75 y 1.
Finalmente, vamos a combinar todas las ideas que hemos visto hasta ahora en un nuevo remix de la Habanera. Habrás visto que he incluido otra parte de la línea de bajo como comentario. Una vez hayas escrito todo en un búfer vacío, dale a Ejecutar para escuchar la composición. Ahora, sin parar el progama, descomenta la segunda línea borrando el # y dándole a Ejecutar de nuevo - ¿a que suena genial? Ahora, empieza a mezclarlo tú mism@ y diviértete.
use_debug false
bizet_bass = (ring :d, :r, :r, :a, :f5, :r, :a, :r)
#bizet_bass = (ring :d, :r, :r, :Bb, :g5, :r, :Bb, :r)
with_fx :reverb, room: 1, mix: 0.3 do
live_loop :bizet do
with_fx :slicer, phase: 0.125 do
synth :blade, note: :d4, release: 8,
cutoff: 100, amp: 1.5
end
16.times do
tick
play bizet_bass.look, release: 0.1
play bizet_bass.look - 12, release: 0.3
sleep 0.125
end
end
end
live_loop :ind do
sample :loop_industrial, beat_stretch: 1,
cutoff: 100, rate: 1
sleep 1
end
live_loop :drums do
sample :bd_haus, cutoff: 110
synth :beep, note: 49, attack: 0,
release: 0.1
sleep 0.5
end
Todo el mundo ha jugado a Minecraft. Seguro que tod@s vosotr@s habéis construido estructuras increíbles, habéis diseñado trampas ingeniosas, e incluso habéis creado complejas líneas de carros con interruptores de roca roja. ¿Cuánt@s habéis hecho una actuación con Minecraft? Apuesto a que no sabíais que se puede usar Minecraft para crear efectos visuales alucinantes, como un/a VJ profesional.
Si tu única forma de cambiar Minecraft era con el ratón, te habrá costado cambiar cosas rápidamente. Por suerte, Raspberry Pi contiene una versión de Minecraft que se puede controlar con código. También tiene una app llamada Sonic Pi que no sólo hace fácil programar Minecraft, sino que lo hace increíblemente divertido.
En el artículo de hoy, vamos a enseñarte algunos consejos y trucos que hemos usado para dar conciertos en discotecas y escenarios por todo el mundo.
Empecemos…
Vamos a empezar con un ejercicio fácil de calentamiento, para refrescar los conceptos básicos. Primero, enciende tu Raspberry Pi e inicia Minecraft y Sonic Pi. En Minecraft, crea un nuevo mundo, y en Sonic Pi, escoge un búfer vacío y escribe este código:
mc_message "Comencemos..."Dale al botón de Ejecutar y verás el mensaje en la ventana de Minecraft. Vale, ya estamos en marcha, ahora vamos a divertirnos…
Cuando usamos Minecraft para crear efectos visuales, intentamos pensar en algo que sea interesante y que al mismo tiempo sea fácil de generar con código. Un truco muy chulo es crear una tormenta de arena, dejando caer bloques de arena del cielo. Para ello necesitamos algunas funciones básicas:
sleep - para insertar una pausa entre acciones
mc_location - para conocer nuestra posición actual
mc_set_block - para colocar bloques de arena en un sitio en concreto
rrand - para generar valores aleatorios dentro de un rango
live_loop - para hacer que llueva arena constantemente
Si no estás familiarizad@ con funciones como rrand, sólo tienes que escribir la palabra en tu búfer, hacer click en ella, y teclear el atajo de teclado Control-i para mostrar la documentación incluida en Sonic Pi. También puedes navegar por la pestaña lang en el sistema de Ayuda y mirar las funciones directamente, entre otras cosas alucinantes que puedes hacer.
Vamos a hacer que llueva un poco antes de desatar completamente el poder de la tormenta. Mira tu posición actual y úsala para crear unos cuantos bloques de arena en el cielo, cerca de ti:
x, y, z = mc_location
mc_set_block :sand, x, y + 20, z + 5
sleep 2
mc_set_block :sand, x, y + 20, z + 6
sleep 2
mc_set_block :sand, x, y + 20, z + 7
sleep 2
mc_set_block :sand, x, y + 20, z + 8Cuando le des a Ejecutar, puedes mirar a tu alrededor, ya que los bloques pueden empezar a caer detrás tuya, dependiendo de a dónde estés mirando ahora mismo. No te preocupes; si no los has llegado a ver, sólo tienes que darle a Ejecutar de nuevo para tener otra ronda de lluvia de arena - ¡asegúrate de que miras en la dirección adecuada!
Vamos a hacer un repaso rápido lo que está pasando. En la primera línea hemos usado la posición de Steve en coordenadas con la función mc_location, y las hemos puesto en las variables x, y y z. En las siguientes líneas hemos usado la función mc_set_block para colocar unos cuantos bloques de arena en las mismas coordenadas que Steve, pero con algunas modificaciones. Escogimos la misma coordenada x, una coordenada y 20 bloques más alta, y coordenadas z cada vez más grandes, para que la arena caiga en una línea que se aleja de Steve.
¿Por qué no coges el código y empiezas a trastear tú mism@? Prueba a añadir más líneas, cambia las pausas, mezcla :sand con :gravel (gravilla), y escoge distintas coordenadas. ¡Experimenta y diviértete!
Vale, es hora de tener la ira de la tormenta… Para ello vamos a desatar todo el poder del live_loop, la habilidad mágica de Soni Pi que desencadena el verdadero poder del live coding - ¡cambiar el código al vuelo mientras se ejecuta!
live_loop :sand_storm do
x, y, z = mc_location
xd = rrand(-10, 10)
zd = rrand(-10, 10)
co = rrand(70, 130)
synth :cnoise, attack: 0, release: 0.125, cutoff: co
mc_set_block :sand, x + xd, y+20, z+zd
sleep 0.125
end¡A que mola! Estamos dando vueltas muy rápido (8 veces por segundo), y en cada segundo estamos encontrando la posición de Steve igual que antes, pero después generamos 3 valores aleatorios:
xd - la diferencia de x, entre -10 y 10
zd - la diferencia de z, también entre -10 y 10
co - un valor de cutoff para el filtro de paso bajo, entre 70 y 130
Después usamos esos valores aleatorios en las funciones synth y mc_set_block, con lo que tenemos arena cayendo en posiciones aleatorias alrededor de Steve, al mismo tiempo que se oye un sonido percusivo de lluvia, que viene del sintetizador :cnoise.
Para aquell@s que no conozcáis los live loops, son la parte donde empieza la diversión en Sonic Pi. Mientras el código se ejecuta y diluvia la arena, prueba a cambiar uno de los valores, tal vez el tiempo de pausa (sleep) a 0.25, o el tipo de bloque de :sand a :gravel (gravilla). Ahora dale a Ejecutar de nuevo. ¡Abracadabra! Las cosas han cambiado sin tener que parar el código. Esto te abre las puertas a actuar como un/a verdader@ VJ. Sigue practicando y cambiando cosas. ¿De cuántas formas puedes cambiar los efectos visuales sin parar el código?
Finalmente, otra forma excelente de generar efectos visuales interesantes es crear paredes con patrones, y volar alrededor para verlas de cerca. Para este efecto, necesitamos pasar de colocar los bloques aleatoriamente a colocarlos de forma ordenada. Podemos hacer esto anidando dos iteraciones (dale al botón de Ejecutar y navega por la sección 5.2 del tutorial “Iteración y Bucles” para tener más información sobre las iteraciones). El divertido |xd| después del do significa que xd va a cambiar en cada iteración. La primera vez será 0, luego 1, luego 2… etc. Al anidar dos bloques de iteración juntos como hemos hecho, podemos generar las coordenadas de un cuadrado. Después podemos escoger tipos de bloques aleatoriamente, con un anillo de bloques, para obtener un efecto interesante:
x, y, z = mc_location
bs = (ring :gold, :diamond, :glass)
10.times do |xd|
10.times do |yd|
mc_set_block bs.choose, x + xd, y + yd, z
end
end¡Genial! Mientras nos lo pasamos pipa por aquí, prueba a cambiar bs.choose a bs.tick para pasar de un patrón aleatorio a uno más regular. Prueba a cambiar los tipos de bloque. Para l@s más atrevid@s, podéis probar a meter este cambio en un live_loop, para que los patrones sigan cambiando automáticamente.
Y para el final apoteósico - cambia los dos 10.times a 100.times y dale a Ejecutar. ¡Kaboom! Una pared ENORME con bloques puestos aleatoriamente. ¡Imagina cuánto tiempo te habría llevado construirlo a mano con el ratón! Pulsa la tecla Espacio dos veces para activar el modo vuelo, y baja en picado para ver efectos visuales alucinantes. No pares todavía - usa tu imaginación para darle rienda suelta a tus ideas, y usa el poder de Sonic Pi para hacerlas realidad. Cuando hayas practicado, apaga las luces y ¡muéstrale tu show de VJ a tus amig@s!
En el episodio 4 de esta serie de tutoriales, vimos brevemente la aleatoriedad al programar unos chispeantes riffs de sintertizador. Ya que la aleatoriedad es una parte tan importante de mis conciertos de live coding, pensé que sería útil enseñarte los fundamentos en mayor detalle. Así pues, vamos manos a la obra, ¡a navegar por los flujos aleatorios!
Lo primero que debes aprender y que probablemente te sorprenda cuando empieces a tocar con las funciones aleatorias de Sonic Pi, es que en realidad no son aleatorias. ¿Qué significa esto? Vamos a hacer unas cuantas pruebas. Primero, imagínate un número en tu cabeza de 0 a 1. Recuérdalo y no me lo digas. Ahora déjame adivinar… era 0.321567? Bah, esto no se me da bien. Déjame intentarlo de nuevo, pero ahora le vamos a pedir a Sonic Pi que escoja el número. Abre Sonic Pi v2.7+ (versión 2.7 o posterior) y pídele un número aleatorio, pero de nuevo, no me digas cuál es:
print randVeamos… ¿es 0.75006103515625? ¡Sí! Ja ja, veo que no te lo crees. Bueno, tal vez tuve suerte. Probemos de nuevo. Dale al botón de Ejecutar y mira qué te sale… ¿Cómo? ¿Otra vez 0.75006103515625? ¡Esto no puede ser aleatorio! Tienes razón, no lo es.
¿Qué está pasando? En estos casos l@s informátic@s usamos el palabrejo determinismo. Sencillamente, esta palabra significa que nada ocurre al azar y que todo está predestinado. Tu versión de Sonic Pi está destinada a devolver siempre 0.75006103515625 en el programa de arriba. Esto puede parecerte inútil, pero voy a intentar convencerte de que es una de las partes más potentes de Sonic Pi. Si me sigues, aprenderás cómo confiar en la naturaleza determinista de la aleatoriedad de Sonic Pi, y la usarás como un bloque de construcción fundamental para tus composiciones y conciertos de live coding.
Cuando abres Sonic Pi, éste carga en memoria una secuencia de 441.000 valores aleatorios generados previamente. Cuando llamas a una función aleatoria como rand o rrand, se usa esta lista de valores aleatorios para generar tu resultado. Cada llamada a una función aleatoria consume un valor de esta lista. Por tanto, la décima llamada a una función aleatoria usará el décimo valor de la lista. Además, cada vez que pulsas el botón de Ejecutar, la lista se resetea para esa ejecución. Por eso pude adivinar el resultado de rand, y por eso la melodía ‘aleatoria’ era siempre la misma. La versión de Sonic Pi de todo el mundo usa exactamente la misma lista aleatoria, lo que es muy importante cuando empezamos a compartir nuestras canciones con otras personas.
Vamos a usar lo que hemos aprendido para generar una melodía aleatoria que se repita:
8.times do
play rrand_i(50, 95)
sleep 0.125
endEscribe esto en un búfer vacío y dale a Ejecutar. Escucharás una melodía hecha con notas ‘aleatorias’ entre 50 y 95. Cuando haya acabado, dale a Ejecutar de nuevo y escucharás exactamente la misma melodía.
Sonic Pi contiene un montón de funciones para trabajar con la lista de valores aleatorios. Aquí tienes una lista de las más útiles:
rand - Sencillamente devuelve el siguiente valor de la lista aleatoria
rrand - Devuelve un valor aleatorio dentro de un rango
rrand_i - Devuelve un número entero aleatorio dentro de un rango
one_in - Devuelve verdadero o falso dependiendo con una probabilidad determinada
dice - Imita el lanzar un dado, devolviendo un valor entre 1 y 6
choose - Elige un valor aleatorio de una lista
Mira la documentación en el sistema de Ayuda para más información y ejemplos.
Aunque poder repetir una secuencia de notas es esencial para poder reproducir tu riff en el concierto, puede que no sea exactamente lo que buscas. ¿No sería genial poder probar con distintos riffs y escoger el que mśa te guste? Aquí es donde empieza la magia.
Podemos ajustar la lista de valores aleatorios manualmente, con la función use_random_seed. En informática, una semilla aleatoria (random seed) es el punto de partida desde el cual una nueva lista de valores aleatorios puede brotar y florecer. Vamos a probarlo:
use_random_seed 0
3.times do
play rrand_i(50, 95)
sleep 0.125
end¡Genial!, tenemos las tres primeras notas de nuestra melodía aleatoria de arriba: 84, 83 y 71. Ahora podemos cambiar la semilla a un valor distinto. A ver qué te parece así:
use_random_seed 1
3.times do
play rrand_i(50, 95)
sleep 0.125
endInteresante, obtenemos 83, 71 y 61. Puede que te hayas fijado en que los dos primeros números son los mismos que los dos últimos números de antes… no es una coincidencia.
Recuerda que la lista de valores es sencillamente una lista gigante de valores previamente calculados. Usar una semilla aleatoria sólo nos hace saltar a un punto dentro de la lista. Otra forma de verlo: imagínate una baraja de cartas gigante que ha sido barajada previamente. Usar una semilla aleatoria es como cortar la baraja en un punto. Lo mejor de esto es precisamente que puedes saltar por la lista de valores, lo que nos da un gran poder cuando hacemos música.
Vamos a visitar de nuevo nuestra melodía aleatoria de 8 notas con nuestra nueva habilidad para resetear la lista aleatoria, pero ahora vamos a meter un live loop, para poder probar cosas mientras suena:
live_loop :random_riff do
use_random_seed 0
8.times do
play rrand_i(50, 95), release: 0.1
sleep 0.125
end
endAhora, mientras sigue sonando, cambia el valor de la semilla de 0 a algo distinto. Prueba 100, o 999. Prueba con tus propios valores, experimenta y juega con ello: a ver qué semilla genera el riff que más te guste.
El tutorial de este mes ha sido una inmersión un poco técnica en el sistema de aleatoriedad de Sonic Pi. Con suerte, te habrá servido para entender cómo funciona y cómo puedes usar la aleatoriedad con seguridad, creando patrones reproducibles en tu música. Es importante recalcar que puedes usar dicha aleatoriedad reproducible donde quieras. Por ejemplo, puedes hacer aleatorios la amplitud de las notas, el ritmo, la cantidad de reverberación, el sintetizador actual, la cantidad de mezcla de un efecto, etc. En el futuro veremos de cerca alguna de estas aplicaciones, pero de momento, déjame enseñarte un ejemplo corto.
Escribe el siguiente código en un búfer vacío, dale a Ejecutar, y empieza a cambiar las semillas, dale a Ejecutar de nuevo (mientras suena) y explora distintos sonidos, ritmos y melodías que puedes hacer. Cuando hayas encontrado algo que te guste, recuerda el valor de la semilla para que puedas usarla más tarde. Finalmente, cuando hayas encontrado unas cuantas semillas que te gusten, márcate un concierto de live coding para tus amig@s; sólo tienes que cambiar entre tus semillas favoritas, creando una pieza completa.
live_loop :random_riff do
use_random_seed 10300
use_synth :prophet
s = [0.125, 0.25, 0.5].choose
8.times do
r = [0.125, 0.25, 1, 2].choose
n = (scale :e3, :minor).choose
co = rrand(30, 100)
play n, release: r, cutoff: co
sleep s
end
end
live_loop :drums do
use_random_seed 2001
16.times do
r = rrand(0.5, 10)
sample :drum_bass_hard, rate: r, amp: rand
sleep 0.125
end
endHasta ahora en esta serie, nos hemos centrado en usar sonidos disparándolos. Hemos descubierto que podemos disparar los distintos sintetizadores de Sonic Pi con play o synth, y hemos aprendido cómo lanzar samples pregrabados con sample. También hemos visto cómo podemos pasar estos sonidos por efectos de estudio, como reverberación y distorsión, usando el comando with_fx. Combina esto con el sistema de tiempo increíblemente preciso de Sonic Pi, y puedes producir una cantidad enorme de sonidos, beats y riffs. Sin embargo, una vez has seleccionado las opciones de un sonido y lo has disparado, no hay forma de cambiar dichas opciones mientras suena, ¿verdad? ¡Pues no! Hoy vas a aprender algo muy potente: cómo controlar sintetizadores en ejecución.
Hagamos un sonido simple. Arranca Sonic Pi y en un buffer libre escribe lo siguiente:
synth :prophet, note: :e1, release: 8, cutoff: 100Ahora pulsa el botón de Ejecutar (arriba a la izquierda) para escuchar un adorable y estruendoso sintetizador. No pares, ejecútalo varias veces para que tengas una primera impresión. Vale, ¿lo tienes? Entonces, ¡vamos a empezar a controlarlo!
Una funcionalidad poco conocida de Sonic Pi es que las funciones play, synth y sample devuelven algo llamado SynthNode (nodo de sintetizador), que representa un sonido en ejecución. Puedes capturar un SynthNode usando una variable normal y corriente, y luego controlarlo más tarde. Por ejemplo, vamos a cambiar la opción cutoff: después de 1 beat:
sn = synth :prophet, note: :e1, release: 8, cutoff: 100
sleep 1
control sn, cutoff: 130Veamos cada línea una por una:
En primer lugar tenemos el sintetizador :prophet que usa la función synth como de costumbre. Sin embargo, hemos capturado el resultado en una variable llamada sn. Podríamos haber llamado a esta variable de cualquier forma, como synth_node o jane - el nombre no importa. Lo que sí es importante es escoger un nombre que tenga sentido para ti cuando des tu concierto, o para otras personas que quieran leer tu código. Yo he usado sn porque es una abreviatura de synth node.
En la línea 2 hemos usado un comando sleep normal y corriente. Esto no hace nada especial; sencillamente, le pide al ordenador que espere 1 beat antes de moverse a la siguiente línea.
En la línea 3 empieza la diversión con el tema del control. Aquí hemos usado la función control para decirle a nuestro SynthNode en ejecución que cambie su valor de cutoff a 130. Si le das al botón de Ejecutar, escucharás el sintetizador que empieza a tocar como antes, pero después de 1 beat verás que cambia a un sonido mucho más brillante.
Opciones Modulables
La mayoría de las opciones para sintetizadores y efectos de Sonic Pi se pueden cambiar después de haber sido disparadas. Sin embargo, esto no pasa con todas. Por ejemplo, las opciones de envolvente en attack:, decay:, sustain: y release: sólo se pueden controlar cuando disparas el sintetizador. Es fácil saber qué opts puedes cambiar y cuáles no puedes cambiar; busca el sintetizador o efecto que quieras en la documentación, baja hasta la documentación de las opts, y busca las frases “Puede ser cambiado mientras se toca” o “No se puede cambiar una vez iniciado”. Por ejemplo, la documentación para la opción attack: del sintetizador :beep nos deja claro que no se puede cambiar esa opción después de disparar el sintetizador:
Default: 0 Debe ser cero o mayor No se puede cambiar una vez disparado Escalado con el valor actual de BPM
Mientras un sintetizador está en ejecución, no estás limitado a cambiarlo sólo una vez: puedes cambiarlo tantas veces como quieras. Por ejemplo, podemos convertir nuestro :prophet en un mini arpegiador con el siguiente código:
notes = (scale :e3, :minor_pentatonic)
sn = synth :prophet, note: :e1, release: 8, cutoff: 100
sleep 1
16.times do
control sn, note: notes.tick
sleep 0.125
endHemos añadido unas cosillas extra en este fragmento de código. Primero, hemos definido una nueva variable llamada notes que contiene las notas por las que nos gustaría pasar (por cierto, arpegiador sólo es un palabrejo para algo que da vueltas sobre una lista de notas en orden). Segundo, hemos reemplazado nuestra llamada a control por una iteración que la llama 16 veces. En cada llamada a control, hacemos .tick sobre nuestro anillo de notas (notes), que se repite automáticamente cuando llegamos al final (gracias al fabuloso poder de los anillos de Sonic Pi). Para tener algo más de variedad, prueba a reemplazar .tick por .choose, a ver si puedes escuchar la diferencia.
Fíjate en que podemos cambiar varios opts a la vez. Prueba a cambiar la línea de control por la siguiente, y escucha la diferencia:
control sn, note: notes.tick, cutoff: rrand(70, 130)Cuando controlamos un SynthNode, éste responde exactamente a tiempo y cambia al instante el valor del opt por uno nuevo, como si hubieras presionado un botón o hubieras accionado un interruptor. Esto puede sonar rítmico y percusivo - especialmente si el opt controla un aspecto del timbre, como cutoff:. Sin embargo, a veces no quieres que el cambio sea instantáneo. Tal vez quieras moverte suavemente del valor actual al nuevo, como si estuvieras moviendo un deslizador o un dial. Por supuesto, Sonic Pi también puede hacer esto, usando los opts _slide:.
Cada opción que puede ser modificada también tiene una opción _slide: correspondiente, que permite especificar el tiempo de deslizamiento (slide). Por ejemplo, amp: tiene amp_slide:, y cutoff: tiene cutoff_slide:. Estas slide opts son muy distintas al resto de opts, ya que le dicen a la nota del sintetizador cómo comportarse la siguiente vez que sean controladas. Vamos a echarle un vistazo:
sn = synth :prophet, note: :e1, release: 8, cutoff: 70, cutoff_slide: 2
sleep 1
control sn, cutoff: 130Fíjate en que este ejemplo es exactamente igual que el de antes, excepto por el cutoff_slide:. Esto le dice al sintetizador que, para la próxima vez que controle su opción cutoff:, tiene que usar 2 beats para deslizarse desde el valor actual hasta el nuevo valor. Por eso puedes escuchar el cutoff moverse de 70 a 130 cuando usas control. Esto le da al sonido un toque dinámico muy interesante. Ahoa prueba a cambiar el tiempo de cutoff_slide: a un valor más corto, como 0.5, o un valor más largo, como 4, para ver cómo cambia el sonido. Recuerda, puedes hacer slide entre cualquiera de las opciones modificables de esta forma, y cada valor de _slide: puede ser totalmente distinto. Puedes hacer que el cutoff cambie lentamente, que el amp cambie rápido y que el pan cambie a un ritmo intermedio; configúralo a tu gusto, como estés pensando para tu nueva creación…
Veamos un breve ejemplo que demuestra el poder de controlar sintetizadores después de haberlos disparado. Fíjate en que también puedes hacer slide con los efectos igual que con los sintetizadores, aunque con una sintaxis ligeramente distinta. Mira la sección 7.2 del tutorial incluido en Sonic Pi para más información sobre el control de los FX (efectos).
Copia el código en un búfer separado y escúchalo unos instantes. No dejes que se acabe ahí: juega con el código. Cambia los tiempos de slide, cambia las notas, el sintetizador, los FX y los tiempos de pausa, ¡a ver si puedes convertirlo en algo totalmente distinto!
live_loop :moon_rise do
with_fx :echo, mix: 0, mix_slide: 8 do |fx|
control fx, mix: 1
notes = (scale :e3, :minor_pentatonic, num_octaves: 2).shuffle
sn = synth :prophet , sustain: 8, note: :e1, cutoff: 70, cutoff_slide: 8
control sn, cutoff: 130
sleep 2
32.times do
control sn, note: notes.tick, pan: rrand(-1, 1)
sleep 0.125
end
end
endEl último mes hicimos una inmersión técnica en el sistema de aleatoriedad de Sonic Pi. Exploramos cómo podemos usarlo para añadir nuevos niveles de control dinámico en nuestro código, de forma determinista. Este mes vamos a continuar con nuestra inmersión técnica, para enseñarte el sistema de tick único en Sonic Pi. Al final del artículo, podrás recorrer tus ritmos y riffs con total facilidad, avanzando en tu camino para ser un/a DJ de live coding.
Normalmente, cuando hacemos música, queremos hacer distintas cosas dependiendo de cómo sea nuestro beat. Sonic Pi tiene un sistema especial para contar beats llamado tick que te proporciona un control muy preciso sobre cuándo ocurre un beat, e incluso permite usar distintos beats con sus propios tempos.
Vamos a tocar un poco. Para hacer avanzar el beat sólo tenemos que llamar a tick. Abre un búfer nuevo, escribe el siguiente código y dale a Ejecutar:
puts tick #=> 0Esto devuelve el beat actual: 0. Fíjate en que aunque presiones el botón de Ejecutar varias veces, siempre va a devolver 0. Esto pasa porque cada ejecución empieza un beat nuevo, empezando a contar desde 0. Sin embargo, mientras la ejecución siga activa, podemos hacer avanzar el beat tantas veces como queramos:
puts tick #=> 0
puts tick #=> 1
puts tick #=> 2Cuando veas el símbolo #=> al final de una línea de código, significa que esa línea va a escribir el texto que queda al lado derecho. Por ejemplo, puts foo #=> 0 significa que el código puts foo imprime0 en el log en ese momento de la ejecución.
Hemos visto que tick hace dos cosas. Tick incrementa (añade uno) y devuelve el beat actual. A veces sólo queremos ver el beat actual sin tener que incrementarlo, lo que podemos hacer con look:
puts tick #=> 0
puts tick #=> 1
puts look #=> 1
puts look #=> 1En este código incrementamos el beat dos veces haciendo tick y entonces llamamos look dos veces. Veremos los siguientes valores en el log: 0, 1, 1, 1. Los dos primeros ticks han devuelto 0, después 1 como esperábamos, finalmente los dos looks simplemente devolvieron el ultimo valor del beat dos veces, lo cual ha sido 1.
Así que ahora podemos avanzar el beat con tick, y comprobar el beat con look. ¿Y ahora qué? Necesitamos algo sobre lo que hacer tick. Sonic Pi utiliza anillos para representar riffs, melodías y ritmos, y el sistema de ticking ha sido diseñado específicamente para trabajar con anillos. De hecho, los anillos tienen su propia versión de tick (.tick, con punto) que hace dos cosas. Primero, actúa como un tick normal e incrementa el beat. Segundo, obtiene el valor del anillo usando el beat como índice (posición dentro del anillo). Veamos:
puts (ring :a, :b, :c).tick #=> :a.tick es una versión especial (con un punto delante) de tick, que devuelve el primer valor del anillo :a. Podemos coger cada uno de los valores del anillo llamando .tick varias veces:
puts (ring :a, :b, :c).tick #=> :a
puts (ring :a, :b, :c).tick #=> :b
puts (ring :a, :b, :c).tick #=> :c
puts (ring :a, :b, :c).tick #=> :a
puts look #=> 3Mira el log y allí verás :a, :b, :c y de nuevo :a. Fíjate que look devuelve 3. Las llamadas a .tick funcionan como si fueran llamadas normales a tick- incrementan el beat local.
El poder read viene cuando mezclas tick con rings y live_loops. Cuando están combinados tenemos todas las herramientas necesarias para construir y también entender un simple arpegiador. Solo necesitamos cuatro cosas:
Un ring que contiene las notas que queremos repetir. Una forma de incrementar y obtener el beat. La capacidad de tocar una nota en función del beat actual. Una bucle para mantener al arpegiador repitiéndose.
Estos conceptos pueden ser comprobados en el siguiente código:
notes = (ring 57, 62, 55, 59, 64)
live_loop :arp do
use_synth :dpulse
play notes.tick, release: 0.2
sleep 0.125
endVeamos cada una de estas líneas. Primero definimos nuestro ring de notas que reproduciremos continuamente. Entonces creamos un live_loop llamado :arp que hace loop a nuestro alrededor. Cada vuelta en el live_loop ponemos nuestro synth en :dpulse y entonces tocamos la siguiente nota usando.tick. Recuerda que esto incrementará nuestro contador de beats y usará el último valor del beat como el índice para nuestro ring de notas. Finalmente, esperamos un octavo de beat antes de volver a empezar el loop.
Una cosa que hay que saber es que los ticks son locales al live_loop. Esto quiere decir que cada live_loop tiene su propio contador de beats independiente. Esto es mucho más potente que tener un metrónomo y ritmo global . Veamos como funciona esto:
notes = (ring 57, 62, 55, 59, 64)
with_fx :reverb do
live_loop :arp do
use_synth :dpulse
play notes.tick + 12, release: 0.1
sleep 0.125
end
end
live_loop :arp2 do
use_synth :dsaw
play notes.tick - 12, release: 0.2
sleep 0.75
endUna causa de confusiones habituales con el sistema de tick de Sonic Pi es cuando la gente quiere hacer tick en varios rings dentro del mismo live_loop:
use_bpm 300
use_synth :blade
live_loop :foo do
play (ring :e1, :e2, :e3).tick
play (scale :e3, :minor_pentatonic).tick
sleep 1
endAunque cada live_loop tiene su propio contador de beat (independiente del resto), estamos llamando a .tick dos veces dentro del mismo live_loop. Esto significa que el beat se incrementa dos veces en cada vuelta. Esto puede generar polirritmos interesantes, pero normalmente no es lo que queremos. Hay dos soluciones para este problema. Una opción es llamar a tick manualmente al principio del live_loop, y usar .look para mirar el beat actual en cada live_loop. Otra opción es pasarle un nombre único a cada llamada a .tick, como .tick(:foo). De esta forma, Sonic Pi crea un contador de beat separado para cada tick que has nombrado, y realiza su seguimiento. De esta forma, ¡puedes trabajar con tantos beats como necesites! Mira la sección 9.4 (ticks con nombre) del manual incluido en Sonic Pi para más información.
Juntemos todo este conocimiento de los ticks, rings y live_loops en un ejemplo final. Como de costumbre, no consideres esto como una pieza acabada. Empieza cambiando cosas y jugando con ellos a ver en que puedes transformarlo. Nos vemos…
use_bpm 240
notes = (scale :e3, :minor_pentatonic).shuffle
live_loop :foo do
use_synth :blade
with_fx :reverb, reps: 8, room: 1 do
tick
co = (line 70, 130, steps: 32).tick(:cutoff)
play (octs :e3, 3).look, cutoff: co, amp: 2
play notes.look, amp: 4
sleep 1
end
end
live_loop :bar do
tick
sample :bd_ada if (spread 1, 4).look
use_synth :tb303
co = (line 70, 130, steps: 16).look
r = (line 0.1, 0.5, steps: 64).mirror.look
play notes.look, release: r, cutoff: co
sleep 0.5
endCuando la gente descubre Sonic Pi, una de las primeras cosas que aprenden es lo fácil que resulta tocar sonidos pre-grabados usando la función sample. Por ejemplo, puedes tocar un loop de batería con sonido de tecno industrial, escuchar el sonido de un coro, o incluso oír un tocadiscos… todo con una sola línea de código. Sin embargo, mucha gente no se da cuenta de que puedes cambiar la velocidad del sample que estás tocando, consiguiendo efectos muy chulos y un logrando un nuevo nivel de control de tus sonidos grabados. Ahora, abre Sonic Pi y, ¡vamos a estirar samples!
Para cambiar la velocidad a la que suena un sample (playback rate), usamos la opción rate::
sample :guit_em9, rate: 0.5Si escribimos un rate: de 1, el sample suena a la velocidad normal. Si queremos tocarlo a la mitad de velocidad, sólo tenemos que usar un rate: de 0.5:
sample :guit_em9, rate: 0.5Elegir (choose)
Además de hacer el sonido más largo y más grave usando una velocidad baja, podemos usar velocidades altas para hacer el sonido más corto y más agudo. Ahora vamos a tocar con un loop de batería. Primero, escucha cómo suena con la velocidad por defecto de 1:
sample :loop_amen, rate: 1Ahora, vamos a acelerarlo un poco:
sample :loop_amen, rate: 1.5¡Ja! Acabamos de pasar de tecno de la vieja escuela al jungle. Fíjate en cómo aumenta la altura de cada nota, y también en cómo se acelera el ritmo. Ahora, prueba con velocidades todavía más altas, y averigua cómo de alto y de corto puedes hacer el loop de batería. Por ejemplo, si usas una velocidad de 100, ¡el loop se convierte en un click!
Seguro que much@s estáis pensando en lo mismo ahora… “¿y qué pasa si usas un número negativo para la velocidad? ¡Muy buena pregunta! Vamos a pensar un momento. Si nuestra opt rate: representa la velocidad a la que se reproduce nuestro sample, 1 es velocidad normal, 2 es el doble de velocidad, y 0.5 es la mitad de velocidad, entonces, ¡con -1 debe sonar al revés! Vamos a probar con una caja de batería. Primero, toca el sample a la velocidad normal:
sample :elec_filt_snare, rate: 1Ahora, ejecutado al revés:
sample :elec_filt_snare, rate: -1Por supuesto, puedes tocarlo al revés y al doble de velocidad con una velocidad de -2, o puedes tocarlo al revés a la mitad de velocidad con un rate: de -0.5. Prueba con distintos valores negativos y diviértete. ¡Suena especialmente curioso con el sample :misc_burp!
Uno de los efectos de modificar la velocidad en los samples es que cuanta mayor es la velocidad, más agudo suena el sample en altura; a menor velocidad, más grave suena. Puede que hayas escuchado este efecto en tu día a día, cuando vas en bicicleta o en coche y pasas un paso de cebra con pitido; a medida que te acercas a la fuente del sonido, la altura es mayor que cuando estabas más lejos del paso de cebra. Esto se conoce como efecto Doppler. ¿Por qué ocurre?
Veamos un pitido sencillo (beep) representado con una onda de seno. Si usamos un osciloscopio para generar una gráfica del beep, veremos algo parecido a la Figura A. Si dibujamos un beep una octava más agudo, veremos la Figura B, y con una octava más se vería como en la Figura C. Fíjate en que las ondas de notas más agudas son más compactas, y que las notas más graves están más separadas.
El sample de un beep sólo es un montón de números (coordenadas x,y) que dibujan las curvas originales del sonido que se grabó. Mira la Figura D, donde cada círculo representa una coordenada. Para convertir las coordenadas a audio, el ordenador coge cada valor x y le envía su correspondiente valor y a los altavoces. El truco está en que el ordenador no tiene por qué procesar los valores de x y guardarlos al mismo tiempo. O sea, el hueco (la cantidad de tiempo) entre cada círculo se puede estirar o comprimir. Si el ordenador lee los valores de x más rápido que como sonaban en la vida real, los círculos se harán más pequeños y el beep sonará más agudo. También hará el beep más corto, porque pasamos por los círculos más rápido. Puedes ver este efecto en la Figura E.
Por último, tal vez te interese saber que un matemático llamado Fourier demostró que cualquier sonido es en realidad muchas ondas de seno juntas. Por eso, cuando comprimimos y estiramos cualquier sonido grabado, lo que estamos haciendo en realidad es comprimir y estirar muchas ondas de seno al mismo tiempo.
Hemos visto que con una velocidad (rate) más alta, el sonido suena más agudo; y que con una velocidad más baja, el sonido suena más grave. Hay un truco muy fácil y útil que tiene que ver con esto. Cuando duplicas la velocidad, el sonido suena una octava más alto; y al revés, si divides la velocidad por dos, el sonido suena una octava más bajo. Esto quiere decir que si duplicas / divides por dos la velocidad de un sample melódico, va a seguir sonando bastante bien:
sample :bass_trance_c, rate: 1
sample :bass_trance_c, rate: 2
sample :bass_trance_c, rate: 0.5Pero, ¿y si queremos cambiar el rate para que el sample sólo suene un semitono (una tecla más arriba en el piano) más agudo, en vez de una octava entera? Podemos hacerlo fácilmente con Sonic Pi usando la opción rpich::
sample :bass_trance_c
sample :bass_trance_c, rpitch: 3
sample :bass_trance_c, rpitch: 7Si miras los mensajes del registro (log) a la derecha, verás que un rpitch: de 3 se corresponde con un rate de 1.1892, y un rpitch de 7 se corresponde con un rate de 1.4983. Por último, podemos combinar los opts rate: y rpitch::
sample :ambi_choir, rate: 0.25, rpitch: 3
sleep 3
sample :ambi_choir, rate: 0.25, rpitch: 5
sleep 2
sample :ambi_choir, rate: 0.25, rpitch: 6
sleep 1
sample :ambi_choir, rate: 0.25, rpitch: 1Vamos a echarle un vistazo a una pieza sencilla que combina estas ideas. Cópiala en un búfer vacío de Sonic Pi, dale a Ejecutar, escúchala un rato y úsala para empezar tu propia pieza. ¿Has visto qué divertido es jugar con el rate de los samples? Y aquí tienes un ejercicio extra: prueba a grabar tus propios sonidos y a cambiar la velocidad de reproducción para ver qué sonidos locos puedes hacer.
sample :guit_em9rand
Dado (dice)
Dado (dice)Dado (dice)
Escuchemos como suena:
randrand
one_in
one_inrand
Las cosas se ponen interesantes cuando combinas varios samples que se disparan con distintas probabilidades. Por ejemplo:
one_inDe nuevo, ejecuta el código de arriba y empieza a cambiar las probabilidades para modificar el ritmo. También puedes cambiar los samples para crear una sensación completamente nueva. Por ejemplo, ¡prueba a cambiar :drum_cymbal_closed por :bass_hit_c si quieres una sobredosis de bajo!
rand
one_inUna cosa que suelo hacer con este tipo de estructura es recordar qué semillas suenan bien y apuntarlas. De esta forma, puedo recrear fácilmente mis ritmos cuando vuelva a practicar la canción, o cuando la toque en un concierto en el futuro.
rand
Elegir (choose)Este mes vamos a sumergirnos en uno de los efectos más potentes y flexibles de Sonic Pi: el :slicer. Al final de este artículo, habrás aprendido cómo manipular el volumen de nuevas formas muy interesantes. Esto te permitirá crear nuevos ritmos y estructuras rítmicas, ampliando tus posibilidades sonoras.
:prophet
synth :prophet, note: :e1, release: 8, cutoff: 70
synth :prophet, note: :e1 + 4, release: 8, cutoff: 80Ahora, vamos a pasarlo por el efecto :slicer:
with_fx :slicer do
synth :prophet, note: :e1, release: 8, cutoff: 70
synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
endEscucha cómo el slicer le pone y le quita volumen al audio, con un beat regular. Fíjate también en cómo el :slicer afecta a todo el audio generado entre los bloques do/end. Puedes controlar la velocidad a la que se enciende y apaga el audio con la opción phase:, que es una abreviatura de duración de fase (phase duration en inglés). Su valor por defecto es 0.25, que significa 4 veces por segundo usando el BPM por defecto de 60. Hagámoslo más rápido:
with_fx :slicer, phase: 0.125 do
synth :prophet, note: :e1, release: 8, cutoff: 70
synth :prophet, note: :e1 + 4, release: 8, cutoff: 80
end:dsaw
Duración
La duración de fase (phase duration) es la longitud de tiempo para un ciclo de encendido/apagado del volumen. Por tanto, valores más bajos harán al efecto cambiar entre encendido y apagado mucho más rápido que valores más altos. Puedes empezar jugando con valores como 0.125, 0.25, 0.5 y 1.
Por defecto, el efecto :slicer utiliza una onda cuadrada para manipular la amplitud a lo largo del tiempo. Por eso escuchamos la amplitud encendida durante un periodo de tiempo, luego inmediatamente apagada por otro periodo, y encendida de nuevo. Podemos ver que la onda cuadrada sólo es una de las 4 ondas de control distintas que permite usar :slicer. Las otras son la onda de sierra, la onda triangular la onda de (co)seno. Échale un vistazo al diagrama de arriba para ver qué forma tienen estas ondas. También podemos escuchar cómo suenan. Por ejemplo, el siguiente código utiliza el (co)seno como onda de control. Escucha cómo el sonido no se enciende y apaga de forma abrupta, sino que aparece y desaparece gradualmente:
with_fx :slicer, phase: 0.5, wave: 3 do
synth :dsaw, note: :e3, release: 8, cutoff: 120
synth :dsaw, note: :e2, release: 8, cutoff: 100
endJuega con las siguientes formas de onda cambiando la opción wave: a 0 para onda de sierra, 1 para onda cuadrada, 2 para onda triangular, y 3 para onda de seno. Prueba también cómo suenan ondas distintas con valores de phase: distintos.
Cada una de estas ondas se pueden invertir con la opción invert_wave:, que les da la vuelta en torno al eje y. Por ejemplo, en una misma fase, una onda cuadrada suele empezar alto y va bajando gradualmente antes de volver a subir. Con invert_wave:1, la onda empieza bajo y va subiendo gradualmente antes de volver a bajar. Además, la onda de control puede empezar en puntos distintos con la opción phase_offset:, que debería tener un valor entre 0 y 1. Jugando con las opciones phase:, wave:, invert_wave: y phase_offset puedes cambiar drásticamente cómo se modifica la amplitud a lo largo del tiempo.
Duración
Por defecto, :slicer cambia entre los valores de amplitud 1 (totalmente alto) y 0 (silenciado). Esto se puede cambiar con las opciones amp_min: y amp_max. Puedes usarlas con la onda de seno, creando un efecto de tremolo muy sencillo:
with_fx :slicer, amp_min: 0.25, amp_max: 0.75, wave: 3, phase: 0.25 do
synth :saw, release: 8
endEs como si cogieses la rueda de volumen en tu altavoz y lo movieses arriba y abajo ligeramente, con lo que el sonido ‘tiembla’.
Elegir (choose)
with_fx :slicer, phase: 0.125, probability: 0.6 do
synth :tb303, note: :e1, cutoff_attack: 8, release: 8
synth :tb303, note: :e2, cutoff_attack: 4, release: 8
synth :tb303, note: :e3, cutoff_attack: 2, release: 8
endEscucha el interesante ritmo de pulsos que hemos conseguido. Prueba a cambiar la opción probability: (probabilidad) a un valor distinto entre 0 y 1. Valores más cercanos a 0 generarán más espacio entre cada sonido, porque la probabilidad de que el sonido se dispare es mucho menor.
rand
Finalmente, puedes probar a cambiar la posición de ‘reposo’ de la onda de control cuando los tests de probabilidad fallen de 0 a cualquier otra posición, con la opción prob_pos::
with_fx :slicer, phase: 0.125, probability: 0.6, prob_pos: 1 do
synth :tb303, note: :e1, cutoff_attack: 8, release: 8
synth :tb303, note: :e2, cutoff_attack: 4, release: 8
synth :tb303, note: :e3, cutoff_attack: 2, release: 8
endAlgo muy divertido que puedes probar es usar el :slicer para cortar un beat de batería:
with_fx :slicer, phase: 0.125 do
sample :loop_mika
endEsto nos permite coger cualquier sample y crear nuevas posibilidades rítmicas, lo cual es súper divertido. Sin embargo, debes tener cuidado y asegurarte de que el tempo del sample coincida con el BPM actual de Sonic Pi; de lo contrario, el slicing sonará fatal. Por ejemplo, prueba a cambiar el :loop_mika con el sample loop_amen y escucha cómo de mal puede llegar a sonar cuando los tempos no están alineados.
Como ya hemos visto, cambiar el BPM por defecto con use_bpm alarga o comprime los tiempos de silencio y duraciones de envolventes de sintetizadores para que el tempo coincida. El efecto :slicer también necesita esto, ya que la opción phase: se mide en beats, en vez de segundos. Por tanto, podemos arreglar el problema que tiene loop_amen arriba, cambiando el BPM para que coincida con el del sample:
sample :loop_amenVamos a aplicar todas estas ideas en un ejemplo final que, usando el efecto :slicer, crea una combinación muy interesante. Adelante, empieza a cambiarlo y ¡conviértelo en tu propia pieza!
sample :guit_em9, rate: 0.5El último mes le echamos un vistazo a cinco técnicas importantes para manejar bien el live coding; en otras palabras, exploramos cómo podemos usar Sonic Pi para hacer código, igual que usaríamos un instrumento musical. Uno de los conceptos que mencionamos es el de la práctica. Este mes vamos a sumergirnos en más código, y vamos a entender por qué practicar live coding es importante, y cómo podrías empezar.
El mejor consejo que te puedo dar es que te asegures de practicar de forma regular. Por norma, suelo practicar 1 o 2 horas cada día, pero con 20 minutos es suficiente para empezar. Estamos buscando practicar poquito pero cada día; así que si sólo puedes dedicarle 10 minutos, sigue siendo un buen comienzo.
Consejo de práctica nº 1 - empieza a desarrollar una rutina de práctica. Encuentra un buen momento del día que funcione bien para ti, y practica en ese tiempo tantos días de la semana como puedas. Pronto estarás contando las horas para tu sesión de práctica diaria.
Si ves tocar a un/a músic@ profesional tocando en directo, probablemente te darás cuenta de varias cosas. En primer lugar, cuando tocan no miran su instrumento. Sus dedos, brazos y su cuerpo entero saben qué teclas pulsar, qué cuerdas rasguear o qué tambores percutir, sin tener que pensarlo mucho. Esto se conoce como “memoria muscular” y, aunque suene como algo que sólo hacen l@s profesionales, es igual que cuando aprendiste a andar o a montar en bicicleta; práctica a través de la repetición. L@s live coders usan su memoria muscular para liberar sus mentes; no tienen que pensar dónde mover sus dedos, así que pueden centrarse en la música. Esto se conoce como touch typing o mecanografía táctil - escribir sin mirar al teclado.
Consejo de práctica nº 2 - aprende mecanografía táctil. Hay muchas apps, páginas web e incluso juegos que te pueden ayudar a conseguirlo. Encuentra uno que te guste, y úsalo de forma regular hasta que puedas programar sin mirar al teclado.
El cuerpo de un/a músic@ está acondicionado para tocar su instrumento. Por ejemplo, un/a trompetista necesita soplar fuerte, un/a guitarrista necesita agarrar el mástil con fuerza, y un/a baterista necesita golpear la batería durante largos periodos de tiempo. ¿Y qué hay de corporal en el live coding? Como l@s DJs, l@s live coders suelen tocar de pie; ¡algun@s incluso bailan mientras programan! Si practicas live coding sentad@ en tu mesa y luego tienes que estar de pie cuando llegues al concierto, vas a notar la diferencia, y se te va a hacer difícil y frustrante.
Consejo de práctica nº 3 - ponte de pie mientras practicas. La forma más fácil de hacerlo es usar un escritorio de altura regulable. No obstante, si eres como yo y no tienes uno en casa, hay varios apaños que puedes hacer. Lo que suelo hacer yo es usar una tabla de planchar, que funciona bastante bien. También puedes apilar varias cajas o libros grandes en un escritorio normal, y poner tu teclado encima. Asegúrate también de estirarte cuando antes de empezar a practicar, e intenta moverte (o bailar) un poco durante la sesión. Recuerda, nadie te está mirando, así que diviértete, y te sentirás mucho más natural en el escenario.
La mayoría de los instrumentos necesitan ser montados y afinados antes de tocar. A no ser que seas una estrella del rock con un autobús lleno de encargad@s de equipo, serás tú quien monte su instrumento antes de cada concierto. El momento de montar el instrumento suele ser estresante, y es fácil que ocurra algún problema. Una forma de suavizar esta situación en los conciertos es que incluyas el proceso de puesta a punto en tus sesiones de práctica.
Consejo de práctica nº 4 - montar tu equipo también forma parte de tu práctica. Por ejemplo, encuentra una caja o una bolsa donde puedas dejar tu Raspberry Pi, tu teclado, etc. Antes de cada sesión de práctica, saca todas las partes, conecta todo, enciende tu Raspberry Pi… así hasta que tengas Sonic Pi encendido y puedas hacer música. Cuando hayas acabado de tocar, tómate tu tiempo para guardar todo en su sitio. Esto te puede llevar algo de tiempo al principio, pero antes de que te des cuenta, serás capaz de montar y desmontar tu equipo muy rápido, sin pensar.
Una vez hayas montado todo y estés list@ para empezar a tocar, puede que te cueste ver por dónde empezar. Un problema que suele tener la gente es que imaginan qué música quieren hacer pero no saben cómo tocarla, lo que les frustra. ¡Hay gente que no sabe qué música quiere hacer! En primer lugar, no te preocupes; es muy normal y le pasa a cualquier músic@ (incluso si llevan practicando mucho tiempo). Es mucho mejor hacer música que no te gusta exactamente, que no hacer música.
Consejo de práctica nº 5 - dedica parte de tu tiempo a hacer música que no te guste. Tómate tu tiempo para explorar nuevos sonidos e ideas. No te preocupes porque pueda sonar mal si no es el estilo que te gusta. Cuando experimentas de esta forma, ¡aumentas la probabilidad de encontrarte con música que te encante! Aunque el 99% de la música que hagas suene mal, ese 1% restante puede ser el riff o la introducción de tu nueva canción. Olvídate de las partes que no te gusten, y recuerda las que sí te hayan gustado. Cuando haces música con código es todavía más fácil: ¡sólo tienes que darle a Guardar!
rand
Consejo de práctica nº 5 - escribe código en Sonic Pi, pero no le des todavía a Ejecutar. Intenta imaginarte qué va a sonar con ese código. Cuando lo tengas, dale a Ejecutar, escucha, y piensa en qué acertaste y en qué te equivocaste. Repite este proceso hasta que se convierta en una parte natural de tu proceso creativo. Yo cuando practico suelo tener una idea bastante clara de cómo va a sonar mi código. Sin embargo, hay veces en las que me sorprendo con lo que suena; en ese momento paro y pienso en dónde me he equivocado. Cada vez que pasa esto, aprendo nuevos trucos que me permiten expresarme de nuevas formas.
Un problema muy común al practicar es distraerte con otras cosas. Practicar es duro y requiere disciplina, da igual el estilo que toques - desde jazz hasta clásica o electrónica. Si te cuesta empezar a tocar o progresar con lo que tienes, es fácil que te pongas a ver las redes sociales, que mires cosas en Internet, etc. Si te has planificado para practicar 20 minutos, es importante que intentes dedicar ese tiempo de forma productiva.
Consejo de práctica nº 7 - antes de empezar a practicar, intenta deshacerte de todas las distracciones que puedas. Por ejemplo, desconéctate de Internet, deja tu móvil en otro cuarto, e intenta practicar en un sitio en silencio, donde no te vayan a molestar. Intenta concentrarte en escribir tu música; siempre puedes a tus distracciones cuando acabes.
Cuando practiques, tu mente estará llena de ideas nuevas: nuevas direcciones en tu estilo musical, nuevos sonidos que quieres probar, nuevas funciones para escribir, etc. Estas ideas suelen ser tan interesantes que puede que dejes de hacer lo que estés haciendo, para ponerte a trabajar en esas ideas. ¡Esta es otra forma de distracción!
Consejo de práctica nº 8 - escribe un diario de práctica con tu teclado. Cuando tengas una nueva idea, para tu sesión de práctica unos segundos, escribe la idea rápidamente, y olvídate de ella y sigue practicando. Así puedes dedicar tiempo más tarde para pensar en tus ideas, cuando hayas acabado de practicar.
Intenta establecer una rutina de práctica que incorpore todas las ideas nuevas que puedas. Intenta que las sesiones sean divertidas, pero ten en cuenta que la práctica puede ser dura y requerir bastante trabajo en ocasiones. Sin embargo, todo esto merecerá la pena cuando hayas creado tu primera pieza, o cuando hayas tocado tu primer concierto. Recuerda, ¡la práctica es la clave del éxito!
Esta es la primera parte de una miniserie de artículos donde veremos cómo usar Sonic Pi para hacer diseño sonoro. Haremos un recorrido por las distintas técnicas que tienes para fabricar tu propio sonido. La primera técnica que vamos a ver se llama síntesis aditiva. Puede sonarte complicado, pero el significado se entiende muy fácil si vemos cada palabra por separado. Primero, aditivo significa combinar cosas; segundo, síntesis significa crear sonido. Por tanto, síntesis aditiva no es más que combinar sonidos que tienes para crear sonidos nuevos. Esta técnica de síntesis se usa desde hace mucho tiempo; por ejemplo, los órganos de la edad media tienen un montón de tubos con sonidos muy variados, que puedes controlar con unas palancas. Si tiras de la palanca de un tubo, lo estás ‘añadiendo a la mezcla’, haciendo el sonido mucho más rico y complejo. Vamos a ver ahora cómo podemos tirar de todas las palancas en Sonic Pi.
Empecemos con el sonido más sencillo - la humilde y pura onda de seno:
synth :sine, note: :d3Ahora, veamos cómo estos sonidos se combinan con una onda cuadrada:
synth :sine, note: :d3
synth :square, note: :d3¿Has visto cómo se han juntado los dos sonidos para formar uno más rico? Y no hay por qué parar ahí; podemos añadir tantos sonidos como queramos. En cualquier caso, hay que tener cuidado con cuántos sonidos juntamos. Cuando mezclamos muchos pigmentos para crear nuevos colores, acabamos con un color marrón muy feo; del mismo modo, mezclar muchos sonidos genera un sonido muy sucio.
Vamos a añadir algo al sonido que tenemos para hacerlo un poco más brillante. Podríamos usar una onda triangular una octava por encima (para obtener ese sonido brillante), y ponerle sólo 0.4 de amplitud (amp) para que añada al sonido en vez de taparlo:
synth :sine, note: :d3
synth :square, note: :d3
synth :tri, note: :d4, amp: 0.4Ahora, prueba a crear tus propios sonidos combinando 2 o más sintetizadores, con distintas octavas y amplitudes. Fíjate también en que puedes jugar con las opciones de cada sintetizador para modificar cada fuente de sonido antes de mezclarla con el resto; así puedes conseguir más combinaciones de sonidos.
Hasta ahora, al combinar nuestros sintetizadores, sólo hemos usado la misma altura o hemos cambiado alguno de octava. ¿Cómo sonaría si en vez de restringirnos a octavas, usáramos notas un poco más agudas o un poco más graves? Vamos a probarlo:
detune = 0.7
synth :square, note: :e3
synth :square, note: :e3 + detuneSi desafinamos nuestras ondas cuadradas 0.7 notas, podemos escuchar que suenan ‘mal’. Sin embargo, a medida que nos acercamos a 0, sonará cada vez mejor, ya que la altura de las dos ondas se parece cada vez más. ¡Pruébalo! Cambia el valor del opt detune: de 0.7 a 0.5 y escucha el nuevo sonido. Prueba con 0.2, 0.1, 0.05, 0. Cada vez que cambies el valor, dale a Ejecutar y comprueba cómo cambia el sonido. Fíjate en que los valores bajos de desafinación (detune) como 0.1 producen un sonido ‘grueso’ muy agradable; las alturas de las ondas interactúan de formas muy interesantes, y a menudo sorprendentes.
:dsaw
También podemos pulir nuestro sonido usando distintas opciones y envolventes (envelope) para el disparador de cada sintetizador. Con esto puedes, por ejemplo, hacer que parte del sonido sea percusiva, y que otra parte resuene durante un rato.
detune = 0.1
synth :square, note: :e1, release: 2
synth :square, note: :e1 + detune, amp: 2, release: 2
synth :gnoise, release: 2, amp: 1, cutoff: 60
synth :gnoise, release: 0.5, amp: 1, cutoff: 100
synth :noise, release: 0.2, amp: 1, cutoff: 90En el ejemplo de arriba, le he añadido un elemento percusivo y ruidoso al sonido; además, le he puesto un poco de ruido de fondo que dura un rato. Para ello, primero he usado dos sintetizadores de ruido con valores de corte (cutoff) normales (90 y 100) y con tiempos para soltar (release) cortos; además, he usado un sintetizador de ruido con un tiempo de release mayor pero con un valor de cutoff bajo (lo que hace al ruido menos brillante y más resonante.)
Vamos a combinar todas estas técnicas; vamos usar síntesis aditiva para recrear un sonido sencillo de campana. He dividido este ejemplo en cuatro secciones. En primer lugar, tenemos la sección ‘hit’ (golpe), que es la parte inicial del sonido de la campana, así que usa un envolvente corto (por ejemplo, un release: alrededor de 0.1). Después tenemos la parte del timbre largo de la campana, en la que estoy usando el sonido puro de una onda de seno. Fíjate en que suelo aumentar la nota en 12 y 24, que es el número de notas en una y dos octavas, respectivamente. También le he metido unos cuantos sintetizadores de onda de seno graves, para darle al sonido un poco de bajo y de profundidad. Por último, he usado define para guardar mi código en una función que puedo usar para tocar una melodía. ¡Prueba a tocar tu propia melodía, y juega con los contenidos de la función :bell hasta que tengas un sonido muy loco que te guste!
¡Toca una melodía con tu propia campana!Este ese el segundo artículo de la serie, en la que veremos cómo usar Sonic Pi para hacer diseño sonoro. El último mes vimos la síntesis aditiva, y descubrimos que no es más que juntar muchos sonidos a la vez para crear un nuevo sonido combinado. Por ejemplo, podíamos combinar distintos sintetizadores, o incluso el mismo sintetizador con distinta altura, para crear un sonido muy complejo a partir de ingredientes sencillos. Este mes vamos a ver una nueva técnica conocida como síntesis substractiva, que es sencillamente coger un sonido complejo y quitarle partes para crear algo nuevo. Esta técnica está asociada al sonido de los sintetizadores analógicos de los 60 y los 70; también tuvo que ver con el renacimiento de los sintetizadores analógicos modulares, con estándares muy populares como el Eurorack.
Aunque parezca una técnica complicada o avanzada, Sonic Pi lo hace increíblemente fácil y sencillo… así que vamos a ello.
Para que un sonido quede bien con síntesis sustractiva, debe ser bastante rico e interesante. Esto no significa que necesitemos algo enormemente complejo; de hecho, nos vale con una onda cuadrada (:square) o de sierra (:saw):
synth :saw, note: :e2, release: 4Note que este sonido ya es más interesante y contiene muchas frecuencias diferentes :e2(el segundo Mi del piano) que se añade para crear el timbre. Si esto no tiene mucho sentido para usted, intente compararlo con :beep:
synth :beep, note: :e2, release: 4Como el sintetizador :beep es sólo una onda de seno, escucharás un tono mucho más puro, con la nota :e2 muy clara, y ningún otro ruido que la emborrone (lo que sí escucharías con una onda :saw). El zumbido y la variación de la onda pura de seno es lo que nos permite jugar cuando usamos síntesis sustractiva.
Ahora que tenemos nuestra señal fuente en bruto, el siguiente paso es pasarla por un filtro de algún tipo, que modifica el sonido quitando (o reduciendo) partes del mismo. Uno de los filtros de síntesis sustractiva más conocidos es el filtro de paso bajo (low pass filter). Este filtro deja pasar las partes graves del sonido, pero reduce o borra las partes agudas. Sonic Pi tiene un sistema de efectos sencillo y potente, que incluye un filtro de paso bajo llamado :lpf (de sus siglas en inglés, low pass filter). Vamos a probarlo:
with_fx :lpf, cutoff: 100 do
synth :saw, note: :e2, release: 4
endSi te fijas escucharás cómo se ha quitado parte del zumbido del sonido. De hecho, todas las frecuencias del sonido por encima de la nota 100 han sido reducidas o borradas; sólo se han dejado las frecuencias agudas. Prueba a cambiar el valor del cutoff: a notas más bajas, por ejemplo 70 y luego 50; compara los sonidos que producen.
Por supuesto, :lpf no es el único filtro que tienes para manipular la señal fuente. Otro efecto importante es el filtro de paso alto, llamado :hpf (por sus siglas en inglés, high pass filter) en Sonic Pi. Este hace lo contrario a :lpf, ya que deja pasar los agudos y corta los graves.
with_fx :hpf, cutoff: 90 do
synth :saw, note: :e2, release: 4
endFíjate en cómo suena mucho más brillante y áspero ahora que has borrado las frecuencias bajas. Experimenta con los valores de cutoff: escucha cómo se dejan pasar cada vez más bajos cuantos más bajos sean los valores del filtro, y cómo los agudos van sonando cada vez más pequeños y callados.
:prophet
Hasta ahora sólo hemos producido sonidos estáticos. En otras palabras, el sonido no cambia a lo largo de su duración. Normalmente querrás algo de movimiento en tu sonido para darle más vida a su timbre. Una forma de conseguir esto es con la modulación de filtros (cambiar las opciones del filtro a lo largo del tiempo). Por suerte, Sonic Pi te ofrece herramientas muy potentes para modificar las opciones de un efecto a lo largo del tiempo. Por ejemplo, puedes ponerle un tiempo de deslizamiento a la opción del sintetizador que quieras, siempre y cuando ésta permita modulación; esto le dice a la opción cuánto tarda su valor actual en desplazarse hasta un nuevo valor:
with_fx :lpf, cutoff: 50 do |fx|
control fx, cutoff_slide: 3, cutoff: 130
synth :prophet, note: :e2, sustain: 3.5
endVamos a echarle un vistazo a lo que está pasando. Primero, empezamos un bloque de efecto :lpf normal y corriente, con un valor de cutoff: de 20 (muy bajo). Sin embargo, la primera línea acaba con un |fx| un poco raro al final. Eso es una parte opcional de la sintaxis with_fx, que te permite nombrar y controlar el sintetizador del efecto manualmente. La línea 2 hace justo esto, y controla el efecto para cambiar el opt cutoff_slide: a 4, y el nuevo cutoff: a 130. Con esto, el efecto empezará a deslizar el valor del cutoff: de 50 a 130 a lo largo de 3 beats. Por último, lanzamos un sintetizador con la señal fuente, para que podamos escuchar el efecto del filtro de paso bajo modulado.
Esto es sólo una pequeña muestra de lo que puedes hacer con filtros. Juega con los distintos efectos de Sonic Pi para ver qué clase de sonidos puedes diseñar. Si tu sonido te parece demasiado estático, recuerda que puedes empezar modulando las opciones para crear más movimiento.
Terminemos diseñando una función que ejecutará un nuevo sonido creado con síntesis sustractiva. Intente descubrir qué es lo que sucede - y para aquellos usuarios avanzados de Sonic Pi- vean si pueden descubrir por qué empaqueté todo en la llamada a at (por favor envíen sus respuestas a @samaaron en Twiter).
Rango aleatorio (rrand)(This article was published in issue 9 of the Hello World Magazine)
Code is one of the most creative media that humans have created. The initially obscure symbols of parentheses and lambdas are not just deeply rooted in science and mathematics, they are the closest we have managed to get to casting the same kind of magical spells as Gandalf and Harry Potter. I believe that this provides a powerful means of engagement in our learning spaces. Through the magic of code we are able to conjure up individually meaningful stories and learning experiences.
We are surrounded by magical experiences. From the sleight of hand of a stage magician making the ball disappear into thin air, to the wonder of seeing your favourite band perform on a big stage. It is these “wow” moments that inspire us to pick up a magic book and learn the French Drop or to start jamming power chords on an old guitar. How might we create similarly deep and lasting senses of wonder that will motivate people to practice and learn the fundamentals of programming?
The histories of music and computers have been intricately woven together since the inception of computing machines, or “engines” as Charles Babbage’s powerful analytical engine was called. Back in 1842 the Mathematician Ada Lovelace, who worked very closely with Babbage, saw the creative potential of these engines. Whilst these first engines had originally been designed to accurately solve hard maths problems, Ada dreamt about making music with them:
”..the engine might compose elaborate and scientific pieces of music of any degree of complexity or extent.” Ada Lovelace, 1842.
Of course, today in 2019 much of our music, regardless of genre, has either been composed, produced or mastered with a digital computer. Ada’s dream came true. It is even possible to trace the history back even further. If you see coding as the art of writing sequences of special symbols that instruct a computer to do specific things, then musical composition is a very similar practice. In Western music, the symbols are black dots positioned on a stave of lines that tell the musician which notes to play and when. Intriguingly, if we trace the roots of Western music notation back to the Italian Benedictine monk, Guido d’Arezzo, we find that the dots and lines system that modern orchestras use is just one of a number of notation systems he worked on. Some of the others were much closer to what we might now see as code.
Get
Live Coding (Programación en vivo)
Sonic Pi has been used to perform in a wide range of venues such as school halls, nightclubs, outdoor stages at musical festivals, college chapels and prestigious music venues. For example the amazing Convo project which brought 1000 children together in the Royal Albert Hall to perform an ambitious new composition by composer Charlotte Harding. The piece was written for traditional instruments, choirs, percussion and Sonic Pi code. The pop-artist Jylda also performed with Sonic Pi in the Sage Gateshead for the Thinking Digital Conference, where she created a unique live-coded improvised remix of her song Reeled.
Sonic Pi used as one of the instruments as part of Convo at the Royal Albert Hall. Photo credit: Pete Jones.
Sonic Pi is a code-based music creation and performance tool that builds on all of these ideas. Unlike the majority of computing education software, it is both simple enough to use for education and also powerful enough for professionals. It has been used to perform in international music festivals, used to compose in a range of styles from classical, EDM and heavy metal, and was even reviewed in the Rolling Stone magazine. It has a diverse community of over 1.5 million live coders with a variety of backgrounds all learning and sharing their ideas and thoughts through the medium of code. It is free to download for Mac, PC and Raspberry Pi and includes a friendly tutorial that assumes you know nothing about either code or music.
Sonic Pi was initially conceived as a response to the UK’s newly released Computing curriculum in 2014. The goal was to find a motivating and fun way to teach the fundamentals of programming. It turns out that there is a lot in common and it’s huge fun to explain sequencing as melody, iteration as rhythm, conditionals as musical variety. I developed the initial designs and first iterations of the platform with Carrie Anne Philbin, who brought a teacher’s perspective to the project. Since then, Sonic Pi has undergone iterative improvements thanks to the feedback gained from observing learners and collaborating directly with educators in the classroom. A core design philosophy was to never add a feature that couldn’t be easily taught to a 10 year old child. This meant that most ideas had to be heavily refined and reworked until they were simple enough. Making things simple whilst keeping them powerful continues to be the hardest part of the project.
In order to provide the magical motivation, Sonic Pi’s design was never limited to a pure focus on education. Ideally there would be famous musicians and performers using Sonic Pi as a standard instrument alongside guitars, drums, vocals, synths, violins, etc. These performers would then act as motivational role models demonstrating the creative potential of code. For this to be possible sufficient focus and effort therefore had to be placed on making it a powerful instrument whilst still keeping it simple enough for 10 year olds to pick up. In addition to educators, I also worked directly with a variety of different artists in classrooms, art galleries, studios and venues in the early stages of Sonic Pi’s development. This provided essential feedback which enabled Sonic Pi to grow and ultimately flourish as a tool for creative expression.
There were a number of exciting and unexpected side effects of this dual focus on education and professional musicians. Many of the features are beneficial to both groups. For example, a lot of effort has been put into making error messages more friendly and useful (rather than being a huge complicated mess of jargon). This turns out to be very useful when you write a bug while performing in front of thousands of people. Additionally, functionality such as playing studio quality audio samples, adding audio effects, providing access to live audio from the microphone all turn out to make the learning experience more fun, rewarding and ultimately meaningful.
The Sonic Pi community continues to grow and share amazing code compositions, lesson plans, musical algorithms, and much more. Much of this happens on our friendly forum in_thread (in-thread.sonic-pi.net) which is home to a very diverse group of people that includes educators, musicians, programmers, artists and makers. It is a real joy to see people learn to use code to express themselves in new ways and for that in turn to inspire others to do the same.
From a Computer Science perspective, Sonic Pi provides you with the building blocks to teach you the basics as found in the UK’s curriculum such as sequencing, iteration, conditionals, functions, data structures, algorithms, etc. However, it also builds on a number of important and relevant concepts which have become adopted in mainstream industry such as concurrency, events, pattern matching, distributed computing and determinism - all whilst keeping things simple enough to explain to a 10 year old child.
Get
play 70A melody can be constructed with one more command, sleep:
play 72
sleep 0.5
play 75
sleep 0.5
play 79In this example, we play the note 70 (roughly the 70th note on a piano), wait for 1 second, play note 72, wait for half a second and then play note 75. What’s interesting here is that with just two commands we have access to pretty much all of Western notation (which notes to play and when) and learners can code any melody they’ve ever heard. This leads to huge variety in expressive outcomes whilst focussing on the same computing concept: sequencing in this case.
Taking ideas from the professional music world, we can also play back any recorded sound. Sonic Pi can play any audio file on your computer but also has a number of sounds built-in to make things easy to get started:
sample :loop_amenThis code will play back the drum break which was a pillarstone to early hip-hop, Drum and Bass and Jungle. For example, a number of early hip-hop artists played this drum break back at half speed to give it a more laid-back feeling:
sample :loop_amen, rate: 0.5In the 90s a number of music scenes burst out of new technology which enabled artists to take drum breaks like this apart and reassemble in a different order. For example:
sample :loop_amenrand
Esta sección cubre algo muy útil - de hecho esencial - Conocimiento para sacar el mayor partido a tu experiencia con Sonic Pi.
Cubriremos como sacar provecho de muchos atajos disponibles para tí, como compartir tu trabajo y algunos trucos de ejecución con Sonic Pi.
Sonic Pi es tanto un instrumento como un ambiente de código. Los atajos te hacen tocar Sonic Pi de una manera mucho más eficiente y natural. Especialmente si tocas en frente de una audiencia en vivo.
Mucho de Sonic Pi puede ser controlado a través del teclado. Mientras te familiarizas trabajando con Sonic Pi, probablemente usarás más y más atajos. personalmente soy del tipo toca-teclea (lo que recomiendo aprender) y me frustra el tener que ir al ratón, ya que me ralentiza. Por ello es que utilizo estos atajos regularmente.
Por tanto, si te aprendes los atajos, utilizarás tu teclado de manera eficiente y codificarás como un profesional en poco tiempo.
Sin embargo no intentes aprender todo al mismo tiempo, sólo intenta recordar los que más utilizas y continua añadiendo otros a tú práctica.
Imagina que estás aprendiendo el clarinete. Esperarás que todos los clarinetes de cada constructor tenga controles y digitalizaciones similares. Si no fuese así, sería complicado cambiar de clarinetes y tendrías que usar sólo uno.
Desafortunadamente los tres principales sistemas operativos (Linux, Mac OS X y Windows) vienen con acciones como cortar y pegar determinadas. Sonic Pi intentará honrar estos estándares. Sin embargo priorizaremos consistencia a través de las plataformas dentro de Sonic Pi. Esto significa que te sentirás cómodo y en casa ya sea que toques con la Raspberry Pi, Mac o PC.
Parte de la noción de consistencia es el nombramiento de los atajos. En Sonic Pi usamos los nombre Control y Meta para referirnos a las dos principales combinaciones de teclas. En todas las plataformas Control es igual. Sin embargo, en Linux y Windows, Meta es la tecla Alt, mientras que en Mac es la tecla Command. Por consistencia, utilizaremos el término Meta - sólo recuerda mapear la tecla apropiada a tu OS.
Para mantener las cosas simples y legibles, utilizaremos la abreviación C- para Control más otra tecla y M- por Meta más otra tecla. Por ejemplo, si un atajo te requiere que mantengas apretadas ambas Meta y r, escribiremos elso, así M-r. El - significa que es al mismo tiempo.
Los siguientes son los atajos que encuentro más útiles.
En vez de comenzar tu código conel ratón, puedes simplemente presionar M-r. Similarmente puedes pararlo con M-s.
Sin los atajos de navegación estaría perdido. Así que recomiendo que los aprendas. Estos atajos funcional fenomenalmente cuando hayas aprendido a tocar y teclear, ya que usan letras estándar, en vez de requerir que vayas al ratón o las flechas del teclado.
Puedes moverte al inicio de una línea con C-a, al final de la línea con C-e, una línea arriba con C-p, abajo con C-n, un carácter adelante con C-f, y atrás un carácter con C-b. puedes borrar todos los caracteres desde el cursor hasta el final de la línea con C-k.
Para auto-alinear el código, simplemete presiona M-m.
Para aparecer el sistema de ayuda, presiona M-i. Sin embargo, un atajo mucho más útil es C-i que buscará la palabra debajo del cursor y mostrará los documentos si encuentra algo. ayuda instantánea.
Para una lista completa, mira la sección 10.2 Tabla de Atajos.
Este es un resumen de los atajos principales dentro de Sonic Pi. Te remito a la sección 10.1 para motivación.
En esta lista, usaremos la siguiente convención (donde Meta es uno de los Alt en Windows/Linux o Cmd en Mac):
C-a mantén presionado Control y presiona a al mismo tiempo, después suelta.
M-r mantén presionado Meta y presiona r al mismo tiempo, después suelta.
S-M-z mantén presionado Shift y presiona la tecla Meta, después la tecla z al mismo tiempo, después suelta.
C-M-f mantén presionado Control, después presiona Meta, finalmente la tecla f, después suelta.
M-r - ejecuta el código
M-s - para el código
M-i - muestra el sistema de Ayuda
M-p - muestra las Preferencias
M-{ - Va al buffer de la izquierda
M-} - Va al buffer de la derecha
M-+ - Incrementa el tamaño del texto del buffer actual
M-- - Decrementa el tamaño del texto del buffer actual
M-a - Selecciona todo
M-c - Copia lo seleccionado al buffer de pegado
M-] - Copia lo seleccionado al buffer de pegado
M-x - Corta lo seleccionado al buffer de pegado
C-] - Corta lo seleccionado al buffer de pegado
C-k - Corta hasta el final de la línea
M-v - Pega del buffer de pegado al editor
C-y - Pega del buffer de pegado al editor
C-SPACE - Establece marca. La navegación manipulará ahora la región ressaltada. Usa C-g para escapar
M-m - Alinea todo el texto
Tab - Alinea la línea/selección actual (o lista completa)
C-l - Centra el editor
M-/ - Comenta la línea actual
C-t - Transpone/cambia caracteres
M-u - Convierte la siguiente palabra (o selección) a mayúscula.
M-l - Convierte la siguiente palabra (o selección) a minúscula.
C-a - Mueve al inicio de la línea
C-e - Mueve al final de la línea
C-p - Mueve a la línea anterior
C-n - Mueve a la línea posterior
C-f - Mueve adelante un caracter
C-b - Mueve atrás un caracter
M-f - Mueve adelante una palabra
M-b - Mueve atrás una palabra
C-M-n - Mueve abajo la línea o selección
C-M-p - Mueve arriba la línea o selección
S-M-u - Mueve arriba 10 líneas
S-M-d - Mueve abajo 10 líneas
M-< - Mueve al inicio del buffer
M-> - Mueve al final del buffer
C-h - Borra el caracter previo
C-d - Borra el caracter posterior
C-i - Muestra documentos para la palabra bajo el cursor
M-z - Deshace
S-M-z - Rehace
C-g - Escapa
S-M-f - Cambia al modo de pantalla completa
S-M-b - Cambia la visibilidad de los botones
S-M-l - Cambia la visibilidad de la bitácora
S-M-m - Cambia entre los modos luminoso/Obscuro de pantalla
S-M-s - Guarda los contenidos del búfer en un archivo
S-M-o - Carga los contenidos de un archivo en el búfer
Sonic Pi se trata de compartir y aprender de todos.
Cuando hayas aprendido a codificar música, compartir tus composiciones es tan sencillo como enviar un correo conteniendo tu código. Por favor comparte tu código con los demás, para que ellos puedan aprender de tu trabajo e inclusive utilizar partes del mismo en nuevas obras.
Si tienes dudas de cuál es la mejor manera de compartir tu trabajo con otros, te recomiendo ponerlo en GitHub y tu música en SoundCloud. Así podrás llegar a mayores audiencias.
GitHub es un sitio para compartir código, utilizado por desarrolladores profesionales y artistas para compartir y colaborar con código. La manera más sencilla de compartir una nueva pieza de código (inclusive de obras no terminadas) es creando un Gist. Un Gist es una manera simple de subir tu código para ser visto por los demás para ver, copiar y compartir.
Otra manera de compartir es grabando el audio y subiéndolo a SoundCloud. Una vez subido, otros pueden comentar y discutir tu obra.También recomiendo poner un enlace al Gist de tu código en la descripción de la pista.
Para grabar tu trabajo, presiona el botón Rec y comenzará inmediatamente. Dale a Run para comenzar tu código si no está ya en ejecución. Cuando estes listo con tu grabación, vuelve a presional el parpadeante botón Rec y te pedirá un nombre para el archivo, que será guardado como WAV, el cual puede ser editado y convertido a MP3 por muchos programas libres (prueba Audacity, por ejemplo).
Te invito a compartir tu trabajo y espero realmente que todos nos enseñemos mutuamente nuevos trucos y movimientos con Sonic Pi. Realmente me interesa ver qué es lo que me mostrarás.
Uno de los aspectos más excitantes de Sonic Pi es que usa código como un instrumento musical. Lo que significa que escribir código puede ser visto como una nueva manera de ejecutar música.
Que es lo que llamamos Live Coding.
Cuando hagas código en vivo, te recomiendo que muestres tu pantalla a la audiencia. De otra manera es como tocar guitarra escondiendo tus dedos y cuerdas. Cuando practico en casa, uso una Raspberry Pi y un mini proyector en el muro de mi sala. Puedes usar tu TV o uno de los proyectores de tu escuela/trabajo para dar una muestra. ¡Inténtalo que es muy divertido!
Don’t just play on your own - form a live coding band! It’s a lot of fun jamming with others. One person could do beats, another ambient background, etc. Use the live_audio functionality to combine code with traditional instruments such as a guitar or a microphone.
See what interesting combinations of sounds you can create with code.
Live coding no es completamente nuevo - un puñado de gente lleva haciéndolo por años, típicamente utilizando equipo hecho por ellos mismos. Un buen lugar para encontrar otros live coders es TOPLAP.
Otra fuente importante a explorar el mundo de live coding es Algorave. Aqui puedes encontrar todo lo relacionado a música con live codign para nightclubs.
Sonic Pi soporta una simple API para interactuar con Minecraft Pi - la edición especial de Minecraft instalada en el sistema operativo basado en Linux que trae la Raspberry Pi, elRaspbian.
La integración de Minecraft Pi está diseñada para ser extremadamente fácil de usar. Sólo necesitas lanzar Minecraft Pi y crear un mundo. De ahí tienes libertad de usar mc_* fns tanto como utilizasplay y synth. No hay necesidad de importar algo o instalar librerías. Todo está listo para funcionar.
El API de Minecraft Pi se encarga de manejar tu conexión a la aplicación Minecraft Pi. Esto significa que no tienes algo de lo que preocuparte. Si intentas utilizar el API de Minecraft Pi cuando Minecraft Pi no está en funcionamiento, Sonic Pi te lo dirá. Similarmente, si cierras Minecraft Pi mientras se ejecuta un live_loop que utiliza la API, el bucle se detendrá y te dirá que no se puede conectar. Para reconectar, simplemente lanza Minecraft Pi de nuevo y Sonic Pi detectará automáticamente y recreará la conexión para tí.
La API de Minecraft fue diseñada para trabajar dentro de live_loops. Esto significa que es posible sincronizar modificaciones en tus mundos de Minecraft Pi con modificaciones en tu Sonic Pi. Videos instantáneos de música basada en Minecraft! Nota que Minecraft Pi es software alfa y conocido por algunos problemillas. Si encuentras algunos problemas, reinicia Minecraft Pi y continúa como anteriormente. La funcionalidad de conexión automática de Sonic Pi se encargará por tí.
Es recomendable usar una Raspberry Pi 2 si pretendes correr al mismo tiempo Sonic Pi y Minecraft, especialmente si deseas utilizar las capacidades de Sonic Pi.
Por ahora, Sonic Pi soporta las manipulaciones básicas de bloque y ejcutante, que fueron detalladas en la sección 11.1. En futuras versiones se pretende soportar llamadas de eventos disparadas por interacciones de ejecutantes en el mundo.
Sonic Pi actualmente soporta las siguientes interacciones básicas con Minecraft Pi:
Mostrar mensajes de chat Establecer la posición del usuario Obtener la posición del usuario Establecer el tipo de bloque a una coordenada dada Obtener el tipo de coordenada a una coordenada dada
Veamos cada una de ellas ahora.
Veamos cuán fácil es controlar Minecraft Pi desde Sonic Pi. Primero, asegúrate de tener abiertos tanto Minecraft Pi como Sonic Pi al mismo tiempo y haber entrado a un mundo de Minecraft en el que puedas caminar.
Escribe lo siguiente en un buffer vacío de Sonic Pi:
mc_message "Hola desde Sonic Pi"Cuando presiones el botón Run, verás tu mensaje en la ventana de Minecraft. ¡Felicidades, acabas de escribir tu primer código de Minecraft! ¿fácil, no?
Hagamos un poco de magia. Teletransportémonos a alguna parte. Prueba lo siguiente:
mc_teleport 50, 50, 50Cuando le das al botón Run - ¡boom! Te teletransporta a otro lugar. Lo más usual es que sea un lugar en el cielo y que caigas en un lugar seco o en agua. Ahora, ¿cuáles eran esos números 50, 50, 50? Esas son coordenadas de la posición a la que te quieres teletransportar. Tommos un rato para explorar qué son esas coordenadas y cómo trabajan, porque son muy, muy importantes para progrmar Minecraft..
Imagina un mapa pirata con una gran X marcando la localización de un tesoro. La localización exacta de X puede ser descrita con dos números - cuán lejos en el mapa de izquierda a derecha y qué tan lejos de arriba a abajo. Por ejemplo 10cm cruzando y 8cm arriba. Estos dos números 10 y 8 son coordenadas. Fácilmente podrías imaginar describir las localizaciones de otros tesoros con otros pares de números. Quizás existe un enorme baúl de oro en 2 cruzando y 9 arriba…
Ahora, en Minecraft dos números no son suficientes. También necesitamos saber qué tan alto nos encontramos. Por lo tanto necesitamos tres números:
Cómo de lejos de derecha a izquierda en el mundo - x
Cómo de lejos de frente hacia atrás en el mundo - z
Cómo de alto estamos en el mundo - y
Una última cosa: típicamente describimos estas coordenadas en este orden: x, y, z.
Juguemos con las coordenadas. Navega a algún lugar bonito en el mapa de Minecraft y después pásate a Sonic Pi. Ahora pon el siguiente código:
puts mc_locationCuando presionas el botón Run verás las coordenadas de tu posición actual en la ventan de la bitácora. Apúntalas, muévete adelante en el mundo y vuelve a probar. ¡Nota que las coordenadas han cambiado! Ahora, yo recomiendo que pases algún tiempo repitiendo esto exactamente - muévete un poco en el mundo, mira las coordenadas y repite. Hazlo hasta que sientas cómo cambian las coordenadas cuando te mueves. Una vez lo entiendas, programar con el APi de Minecraft será un paseo.
Ahora que ya sabes cómo encontrar la posición actual y teletransportarte utilizando las coordenadas, tienes entonces las herramientas necesarias para comenzar a construir cosas en Minecraft con código. Digamos que quieres convertir en vidrio el bloque en las coordenadas 40, 50, 60. Super fácil:
mc_set_block :glass, 40, 50, 60Haha, fué realmente fácil. Para ver tu trabajo, simplemente teletranspórtate a las cercanías y echa un vistazo:
mc_teleport 35, 50, 60¡Ahora mira alrededor y deberías ver un bloque de vidrio! Intenta cambiarlo a diamante:
mc_set_block :diamond, 40, 50, 60Si estabas mirando en la dirección correcta, puedes haberlo visto cambiar. Es el comienzo de algo excitante…
Veamos lo último antes de movernos a algo más envolvente. Si damos un set de coordenadas, podemos preguntarle a Minecraft qué tipo de bloque espeecífico es. Intentémoslo con el bloque de diamante que acabamos de crear:
puts mc_get_block 40, 50, 60Yey! Es :diamond. Intenta cambiandolo a glass y preguntar otra vez - ¿dice :glass? Estoy seguro que si :-)
Antes de ponerte a programar en Minecraft Pi como un obseso, podrías ojear la siguiente lista de bloques disponibles:
:air
:stone
:grass
:dirt
:cobblestone
:wood_plank
:sapling
:bedrock
:water_flowing
:water
:water_stationary
:lava_flowing
:lava
:lava_stationary
:sand
:gravel
:gold_ore
:iron_ore
:coal_ore
:wood
:leaves
:glass
:lapis
:lapis_lazuli_block
:sandstone
:bed
:cobweb
:grass_tall
:flower_yellow
:flower_cyan
:mushroom_brown
:mushroom_red
:gold_block
:gold
:iron_block
:iron
:stone_slab_double
:stone_slab
:brick
:brick_block
:tnt
:bookshelf
:moss_stone
:obsidian
:torch
:fire
:stairs_wood
:chest
:diamond_ore
:diamond_block
:diamond
:crafting_table
:farmland
:furnace_inactive
:furnace_active
:door_wood
:ladder
:stairs_cobblestone
:door_iron
:redstone_ore
:snow
:ice
:snow_block
:cactus
:clay
:sugar_cane
:fence
:glowstone_block
:bedrock_invisible
:stone_brick
:glass_pane
:melon
:fence_gate
:glowing_obsidian
:nether_reactor_core