Serie Fibonacci

# fibonacci.py
def fib(i): #Definicion de la funcion
a = 0
b = 1
c = 0
while c < i:
print c, #Mostramos el resultado por pantalla
a = b
b = c
c = a+b

fib(100) #Llamamos a la funcion con el Fibonacci hasta

100
 LedsIntermitentes
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT) ## GPIO 17 como salida
GPIO.setup(27, GPIO.OUT) ## GPIO 27 como salida
def blink():
print ("Ejecucion iniciada... ")
iteracion = 0
while iteracion < 30: ## Segundos que durara la funcion
GPIO.output(17, True) ## Enciendo el 17
GPIO.output(27, False) ## Apago el 27
time.sleep(1) ## Esperamos 1 segundo
GPIO.output(17, False) ## Apago el 17
GPIO.output(27, True) ## Enciendo el 27
time.sleep(1) ## Esperamos 1 segundo
iteracion = iteracion + 2 ## Sumo 2 porque he hecho dos parpadeos
print ("Ejecucion finalizada")
GPIO.cleanup() ## Hago una limpieza de los GPIO

blink() ## Hago la llamada a la funcion blink

Sensor ultrasónico
 Sensor Ultrasónico
import RPi.GPIO as GPIO #Importamos la librería GPIO
import time #Importamos time (time.sleep)
GPIO.setmode(GPIO.BCM) #Ponemos la placa en modo BCM
GPIO_TRIGGER = 25 #Usamos el pin GPIO 25 como TRIGGER
GPIO_ECHO = 7 #Usamos el pin GPIO 7 como ECHO
GPIO.setup(GPIO_TRIGGER,GPIO.OUT) #Configuramos Trigger como salida
GPIO.setup(GPIO_ECHO,GPIO.IN) #Configuramos Echo como entrada
GPIO.output(GPIO_TRIGGER,False) #Ponemos el pin 25 como LOW

try:
while True: #Iniciamos un loop infinito
GPIO.output(GPIO_TRIGGER,True) #Enviamos un pulso de ultrasonidos
time.sleep(0.00001) #Una pequeñña pausa
GPIO.output(GPIO_TRIGGER,False) #Apagamos el pulso
start = time.time() #Guarda el tiempo actual mediante time.time()
while GPIO.input(GPIO_ECHO)==0: #Mientras el sensor no reciba señal...
start = time.time() #Mantenemos el tiempo actual mediante time.time()
while GPIO.input(GPIO_ECHO)==1: #Si el sensor recibe señal...
stop = time.time() #Guarda el tiempo actual mediante time.time() en otra variable
elapsed = stop-start #Obtenemos el tiempo transcurrido entre envío y recepción
distance = (elapsed * 34300)/2 #Distancia es igual a tiempo por velocidad partido por 2 D = (T x V)/2
print distance #Devolvemos la distancia (en centímetros) por pantalla
time.sleep(1) #Pequeña pausa para no saturar el procesador de la Raspberry
except KeyboardInterrupt: #Si el usuario pulsa CONTROL+C...
print "quit" #Avisamos del cierre al usuario
GPIO.cleanup() #Limpiamos los pines GPIO y salimos
 SONIC PI
• Sonic Pi es un editor de música a través de la
programación en el cual se podran ver
condicionantes, asignaciones, bucles y otras
estructuras de datos que nos permitirán
realizar nuestras propias creaciones.
 Comenzar
Comencemos, copia el siguiente código en un
buffer vacío:

live_loop :flibble do
sample :bd_haus, rate: 1
sleep 0.5
end
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
end
Ahora probemos:
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
end
 Sintetizadores
Los primeros beeps
play 70
Ahora intenta
play 75
¿Escuchas la diferencia? Intenta con un número menor:
play 60
Así que números menores hacen pitidos de tonos más graves y
números mayores hacen pitidos de tonos más agudos…justo como en
un piano las teclas más a la izquierda son más graves que las del lado
derecho. De hecho, los números se relacionan con las teclas del piano.
play 47 significa que toque la tecla 47va del piano; play 48 es un tono
arriba (la siguiente tecla a la derecha). Pasa que la tecla número 60 del
piano es la 4ta octava de DO. Intenta con: play 60.
Si nada de esto significa algo para tí, no te preocupes, que así fue
también cuando yo comenzaba. Lo que importa es que sepas que los
números menores significan pitidos más graves que los números
mayores.
 Acordes
Si tocar una nota es divertido, tocar varias al
mismo tiempo lo es aún más. Pruébalo:
play 72
play 75
play 79
Jazzy! cuando escribes múltiples plays, todos se
tocan al mismo tiempo. compruébalo tú mismo
- ¿cuáles suenan bien, mal? Prueba,
experimenta y encuentra por tí mismo.
 Melodías
Si tocar notas y acordes es divertido, ¿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 arpeggio! Entonces, ¿qué significa el 1 en sleep 1? Bien,
significa la duración de dormir. Realmente significa dormir por un pulso, aunque por
ahora podemos pensar que significa dormir por espacio de 1 segundo. Así, ¿cómo
haríamos para que el arpeggio 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 que tienen 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 :E
Recuerda poner los dos puntos ‘:’ delante del nombre de la nota, para que se
ponga rosada. 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 :E4
Si quieres hacer sostenido de una nota, añádele una ‘s’ al nombre de la nota
así: play :Fs3 y si quieres bemolizar, añádele una b así play :Eb3.
 Opciones Synth: Amp y Pan
Asimismo como Sonic Pi te permite controlar
cuál nota tocar o cuál sample disparar, también
provee un completo rango de opciones para
pulir y controlar los sonidos. En este tutorial
cubriremos muchos de estos y exite 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 qué son las opciones.
 Opciones
Sonic Pi apoya la noción de optiones (opts, abreviando) para sus sintetizadores. Opts son
controles que pasas a pla 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, tales como amp: y opciones de envelopes .
Las Opts tienen dos partes principales, su nombre (el nombre del control) y su valor (el valor al
que setearás el control). Por ejemplo, puedes tener un control llamado ‘cheese:’ y querer
setearlo 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 por medio de comas que los separen:
play 50, cheese: 1, beans: 0.5
El orden de los opts no importa, el siguiente será igual al anterior:
play 50, beans: 0.5, cheese: 1
Si 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 accidentalemente 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: 2
 Amplitud
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, 0.5:
play 60, amp: 0.5
Para hacerlo al doble de amplitud 2:
play 60, amp: 2
El 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 65
Por 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: 1
 Paneo

Otro concepto divertido de usar es el paneo pan: el cual controla el

paneo de un sonido en estéreo. Paneando un sonido a la izquierda,
significa que lo escucharás en la bocina izquierda, paneándolo 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 pitido desde la bocina izquierda:
play 60, pan: -1
ahora que salga de la bocina derecha:
play 60, pan: 1
Finalmente, pongámoslo de nuevo al centro (predeterminado):
play 60, pan: 0
 Sintetizadores
Sonic Pi posee un rango de instrumentos que se
llaman synths, que es como abreviamos
sintetizadores. Mientras que los sampleos
representan sonidos pregrabados, 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, tendrás mucha diversión tocando y
explorándolos. Primero, aprendamos a
seleccionar el synth a 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.25
Probemos otro sonido - el profeta:
use_synth :prophet
play 38
sleep 0.25
play 50
sleep 0.25
play 62
sleep 0.25
¿qué tal si combinamos ambos sonidos. Uno después del otro?
Ahora al mismo tiempo:
use_synth :tb303
play 38
sleep 0.25
use_synth :dsaw
play 50
sleep 0.25
use_synth :prophet
play 57
sleep 0.25
Debes notar que el comando use_synth sólo afecta los
siguientes play. Piensa en él como un gran switch - nuevas
llamadas play tocarán el synth que esté en uso. Puedes
mover el synth a un nuevo synth con cada nuevo
use_synth.
Duración con Envelops
En una sección anterior, miramos 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.
A manera de tener una sencilla, pero poderosa
manera de controlar la duración de nuestros
sonidos, Sonic Pi provee la noción de un sobre de
amplitud ADSR (después cubriremos lo que significa
ADSR). Un sobre de amplitud ofrece dos útiles
aspectos de contro:
control sobre la duración del sonido control sobre la
amplitud del sonido
 Duración
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 un
sobre de control de la amplitud y la duración total del sobre es la duración del
sonido. Por lo tanto, al controlar el sobre, controlas la duración.

Amplitud
El sobre 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. Los sobres permiten
deslizar y mantener la amplitud de las partes no-silente. 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 sobres.

Recapitulando lo visto anteriormente, una amplitud de 0 es silencio y una

amplitud de 1 es volumen normal
 Fase Release (desenganche)
La única parte del sobre 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 70
La nota será audible por 1 segundo. Vamos, cronométralo! Esta es la manera
abreviada de decir lo mismo que:
play 70, release: 1
¡Notas 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: 2
Podemos 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.2
La 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:
 Fase de Ataque
Por defecto, la fase de ataque es 0 para todos los sintetizadores, lo que significa que
pasan de amplitud 0 a 1 inmediatamente. Esto le da al sintetizador un percusivo
sonido inicial. Sin embargo, podrías desear encender tu sonido de a poco. Esto se
logra con el operador attack: . Prueba encender tu sonido de a poco:
play 60, attack: 2
sleep 3
play 65, attack: 0.5

Puedes utilizar varios operadores al mismo tiempo. Por ejemplo para un ataque corto
y un release largo, prueba:
play 60, attack: 0.7, release: 4

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
 Fase de Sostenimiento

Adicionalmente a especificar los tiempos de ataque y release, también puedes especificar el tiempo de
sostenimiento para controlar la fase de sostenimiento. Este es el tiempo en el cual el sonido es
mantenido a máxima amplitud entre las fases de ataque y release.

play 60, attack: 0.3, sustain: 1, release: 1

El sostenimiento es útil para importantes sonidos a los que desees darles máxima presencia a la mezcla
antes de entrar a la fase de release. Claro, es totalmente válido usar ambos operandos, attack: y release:
opts a 0 y dejar el sostenimiento sin aparecimiento gradual ni desvanecimiento. Sin embargo, ten en
cuenta que un release de 0 puede producir clicks en el audio y es aconsejable usar un valor muy
pequeño como 0.2.

Fase de Decaimiento

Para un nivel extra de control, también puedes especificar el tiempo de decaimiento. Esta es la fase del
sobre que está entre el ataque el ataque y el sostenimiento, especifica el tiempo donde la amplitud
bajará desde el nivel de ataque al de desvanecimiento attack_level: decay_level: (a menos que
especiques que será sujetado al nivel de sostenimiento sustain_level:). De hecho, el decay: operando es
0 y tanto el ataque como el sostenimiento tienen valor 1, así que deberás especificarlos para que el
tiempo de decaimiento tenga efecto.

play 60, attack: 0.1, attack_level: 1, decay: 0.2, sustain_level: 0.4, sustain: 1, release: 0.5
 Nivel de Decaimiento
Un último truco es que aunque el decay_level: opt está predeterminado a ser el
mismo valor que el sustain_level: puedes ser explícito y asignarles diferentes valores
para un completo control del sobre. Esto permite crear sobres 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 elevado 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

Sobres ADSR
Para resumir, los sobres ADSR de Sonic Pi tienen las siguientes fases:
ataque - tiempo desde amplitude 0 hasta el attack_level,
decaimiento - tiempo para mover la amplitud desde attack_level a decay_level,
sostenimiento - tiempo para mover la amplitud desde decay_level a sustain_level,
release - tiempo para mover la amplitud desde 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.5
 Sample
Otra gran manera de desarrollar tu música es
usando sonidos pre-grabados. En la gran tradición
de la “música concreta”, 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
los sampleos. No sólo viene con cerca de 90
sampleos de libre dominio para que ser utilizados,
sino que te deja manipular los tuyos. Veamos…
 Disparando sampleos
Ejecutar pitidos es sólo el principio. Algo que sí es divertido es disparar sampleos pre-
grabados. Inténtalo:
sample :ambi_lunar_land
Sonic Pi incluye muchos sampleos para que uses. Utiliza el comando play para
dispararlos. Para tocar múltiples sampleos y notas, simplemente escríbelos uno detrás
del otro:
play 36
play 48
sample :ambi_lunar_land
sample :ambi_drone
Si quieres espacearlos 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
miraremos cómo controlar la duración de los
sonidos con los sobres.
 Amplificando los sampleos
Puedes cambiar la amplitud de los sampleos exactamente de la misma
forma que utilizamos para los sintetizadores:
sample :ambi_lunar_land, amp: 0.5

Paneando sampleos

También podemos utilizar el parámetro pan: en sampleos. Por

ejemplo, aquí te muestro como tocaríamos la pausa amén en el oído
izquierdo y después a la mitad, la tocaríamos en el oído derecho:
sample :loop_amen, pan: -1
sleep 0.877
sample :loop_amen, pan: 1
Nota que al 0.877 (en segundos) está la mitad de la duración del
sampleo :loop_amen .

Finalmente, nota que si seteas algunos sintetizadores por defecto con

use_synth_defaults (que discutiremos luego), estos serán ignorados
por sample
 Cambiando la Velocidad
Ejecutemos uno de los sonidos ambiente:
:ambi_choir. Para tocarlo con la velocidad
predeterminada, puedes añadir rate: a sample:
sample :ambi_choir, rate: 1
Así lo ejecuta a tiempo normal (1), nada especial.
Sin embargo, podemos cambiar ese número a
otros. ¿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 ello
en más detalle.
 Estiremos
Un sample que es divertido estirar y comprimir es el Amen
Break. A velocidad normal, podemos imaginar poner una pista
de drum ‘n’ bass:
sample :loop_amen
Sin embargo, cambiando la velocidad podemos cambiar
“géneros”. Intenta con la mitad de la velocidad para un “hip
hop de vieja escuela”:
sample :loop_amen, rate: 0.5
Si lo aceleramos, entramos al territorio estilístico de jungle:
sample :loop_amen, rate: 1.5
Vamos a nuestro último truco - veamos qué sucede si
utilizamos una velocidad negativa:
sample :loop_amen, rate: -1

Ahaa! ¡Se toca al revés! Ahora intenta toca distintos samples y

velocidades, tales como rápidas y lentísimas, observa qué
sucede.
 Sobres para sampleos
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_amen
Sin 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: 1
Para un desaparecimiento más corto, elegiríamos un valor de ataque
menor:
sample :loop_amen, attack: 0.3
 Aparecimiento y desvanecimiento (Fade In and Out)
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.75
Como 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.
Sostenido explícito
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.75
Ahora 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
 Címbalos
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_open
Puedes 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.1
Puedes 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.1
 Estructuras de Programación
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…
 Bloques
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 62
Para hacer algo con un manojo de código, 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
end
Sin 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. 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.
 Iteración y Bucles
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.
 Repetición
¿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:
¡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 la pieza original 1000 veces? Eso
tomaría muchas líneas de código y lugares a los que ir a
alterar si quisieses cambiar algo.
 Iteración
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
end
 Iteraciones anidadas
Podemos 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
end
 Bucleando
Si 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
end
Lo 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
 Condicionales
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 .
Tirar una moneda
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

end
Debes 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 o false 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
end
Esta vez estaremos pausando por un tiempo distinto dependiendo de cuál
elección hagamos.
 Condicional simple “if”
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
end
Eso tocará acordes de diferentes números con una
probabilidad diferente para cada nota .
 Hilos
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.
 Bucles infinitos
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
end
Como 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.
 Hilos 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
end
Al 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!
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
end
 Ejecutar como hilos
Puede 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.
Ámbito
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.
 Herencia
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.
 Funciones
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:
 Definiendo Funciones
define :foo do
play 50
sleep 1
play 55
sleep 2
end
Aquí 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.
 Llamando las Funciones
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
end
Incluso 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.
 Las funciones permanecen en memoria
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:
foo
Presiona 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).
 Funciones parametrizadas
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 90

Esto 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, 3
Aquí 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
 Sincronización de hilos
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.
Tiempo heredado
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.
 Cue y Sync (funciones)
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
end
Aquí 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
end
Esa 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.
 Nombres de Cue
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
end
 Studio FX
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…
Pedales de Guitarra
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:
Guitar -> Distortion -> Reverb -> Amplifier
Esto 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) !!
 Reberveracion
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 55
Hay 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
end
Uno 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
end
Anidando FX
Uno 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
end
Piensa 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.