Primeros pasos con Reaktor - 7ª parte

Séptima y última parte del tutorial de Reaktor, dedicada a los eventos.

Ha pasado mucho tiempo (noviembre de 2011 :S ) desde que publiqué la anterior entrada del tutorial, y sé que he tenido esto pendiente desde entonces, pero es lo que pasa con estas cosas: no puedes darles prioridad sobre lo que te trae la vida, así que bueno, espero que os quedéis con que nunca es tarde si la dicha es buena y vamos con la, esta vez sí, última entrada del tutorial de Primeros pasos con Reaktor.

En la entrada anterior dije que haríamos un arpegiador con el módulo Poly Display. Ya que es un módulo intensivo en eventos, pensé que sintetizando lo más importante del módulo resultaría una buena entrada, completa y con mucha información, de hecho, empecé a escribir la entrada siguiendo ese mismo esquema. El resultado ha sido un word que, casi sin haber dicho nada, tiene ya 13 páginas sin contar los pantallazos.

Viendo esto, me ha resultado obvio que no iba a funcionar, los módulos Poly Display y Multi Display son módulos muy complejos sobre los que hay demasiado qué decir, no son aptos para un tutorial como este, dedicado a gente que empieza. Quizá en algún momento me anime a escribir algo sobre ellos aprovechando lo que ya tengo escrito, pero no será en este tutorial.

Total, que en vez del módulo Poly Display, usaremos el módulo Event Table, que si bien no tiene las mismas posibilidades en cuanto al aspecto visual, en el práctico es mucho más útil y manejable, su uso es también relativamente intensivo en eventos y se usa en muchos, muchísimos, ensembles tanto de pago como gratis. Eso sí, como compensación por este cambio, lo que voy a hacer es construir desde cero una versión reducida de un secuenciador que empecé hace mucho tiempo, que he ido refinando a lo largo de varios años y es el que uso siempre por defecto en mis ensembles, tanto para testeo como para uso práctico. Tiene un montón de opciones y otro montón de eventos y módulos que explicar, y con esto quiero decir que es bastante complejo para el nivel que llevamos en el tutorial, de hecho es lo más complejo de todo el tutorial, así que tomatelo con calma.

Quede claro también que en Reaktor hay un par de docenas de formas de hacer un secuenciador y un clock, mi forma es simplemente la que más me conviene para mi forma de trabajar (obvio xD ) y la que mejor conozco.

7. LO BASICO DE LOS EVENTOS

7.1. CONECTANDO EL FILTRO. DEBERES

Como siempre, empezamos resolviendo lo que dejamos pendiente en la entrada anterior, que esta vez consiste en conectar al audio del sinte el filtro que hicimos con la stacked macro, algo muy simple en nuestro ensemble.

Si subes hasta el nivel de instrumento, deberías tener algo como esto:

Aunque puede resultar obvio, lo dejaré claro: el filtro tiene que operar con la señal de audio del oscilador, y el resultado tiene que llegar a la macro Mix.

Multiplicar la envolvente antes o después del filtro, es exactamente lo mismo, pero a mí me resulta más cómodo hacerlo antes de que la señal entre al filtro; primero por una lógica muy subjetiva, y es que me parece más lógico tener la señal ya modulada, y después pasarla por el filtro; y segundo por una cuestión de mantener un orden en la estructura, si se multiplica antes del filtro, todo lo que hay que hacerle a la señal del oscilador ya queda hecho en esa parte, y después ya viene el filtro.

En fin, son detalles sin importancia, si lo ves mejor después del filtro, tú mismo... ahora al lío.

Como puedes ver en el pantallazo, he conectado el módulo de multiplicación a nuestra macro Filtro, y dicha macro a su vez a la macro Mix, y listo, ya tenemos un sinte sustractivo de un oscilador y un filtro funcionando ;)

7.2. LOS EVENTOS EN EL NIVEL PRIMARIO. RESUMEN TEORICO

No te asustes, he dicho resúmen ;) . Por mucho que siempre haya intentado que este tutorial sea 100% práctico, a veces es imposible, hay ciertas cosas que tienes que saber y entender antes de empezar.

¿Qué es un evento? Bueno, si ya has tenido un acercamiento, más o menos profundo, a algún lenguaje de programación orientado a objetos o un lenguaje del tipo MAX/MSP, ya tendrás una idea general de lo que es un evento. Así todo... mira, a mí para estas cosas me gusta elaborar una metáfora, creo que así se entiende mejor que con una definición teórica matemática, así que vamos a ello.

Por un momento te voy a pedir que te imagines que los cables de Reaktor, no son cables, sino carreteras... sí, carreteras, puede que te suene un poco infantil al principio, pero sígueme la corriente un rato ;)

Los módulos usan estas carreteras para mandar mensajes a otros módulos, igualito que en cualquier ciudad, llamas al mensajero y te lleva el papelote a la otra punta de la ciudad en la moto :p

Básicamente, eso es un evento en Reaktor: un mensaje que un módulo manda a otro.

Este mensaje puede ser el resultado de una operación matemática, la frecuencia de corte de un filtro, la amplitud de un oscilador, el número de cuadraditos en pantalla, de todo.

Ahora bien, hay ciertas condiciones para usar estos mensajeros.

• Cada carretera conecta UN MÓDULO con un grupo de módulos, y no al contrario, esto ya lo sabías: una salida puede conectarse a muchas entradas, pero una entrada solo puede estar conectada a una salida.
• Cada carretera es de sentido único: solo va del primer módulo al último, nunca en sentido contrario.
• Cada carretera solo tiene un carril: ese módulo que está al principio solo puede mandar un mensaje cada vez, nunca más de uno a la vez.

Por tanto, aquí hay unas cosillas SUPER importantes que tienes que tener SIEMPRE bien metidas en la cabeza:

1. Una salida puede conectarse a muchas entradas, pero una entrada solo puede estar conectada a una salida.
2. Los eventos solo van por los cables en un sentido: desde el módulo de salida hasta el módulo de entrada.
3. En nivel primario, Reaktor no envía más de un evento a la vez, ni siquiera en cables diferentes, es imposible, olvídalo, bórratelo de la cabeza.

Estas tres cosas se cumplen SIEMPRE para los eventos del NIVEL PRIMARIO de Reaktor, y van a darte unos cuantos dolores de cabeza, creeme.

Algunos de los problemas prácticos que te van a dar, son precisamente lo que vamos a ver en esta entrada... así que, ¡basta de teoría! :P

7.3. EL MODULO EVENT TABLE

Te presento al inevitable protagonista de esta entrada, el módulo Event Table:

El módulo es, como su propio nombre indica, una tabla. En realidad se parece más a una base de datos, guardas datos y los lees, solo que aquí los datos tienen que ser números, siempre números. Bien, vamos poco a poco, que este módulo tiene tela.

La tabla que creas al añadir el módulo al ensemble tiene, como de costumbre, dos coordenadas: horizontal y vertical, X e Y. En cada coordenada tienes un valor guardado, que puedes guardar y leer vía la estructura o por el panel, con el ratón. En las propiedades del módulo puedes definir el máximo de X e Y, y el rango del valor que se almacena en cada coordenada con los mismos parámetros que un knob... paciencia, explicaré esto último más adelante. Añade el módulo a tu ensemble en el menú Built-In Module->Event Processing->Event Table, ahora ve a la pestaña Function de sus propiedades y haz click en el botón Set:

Aparecerá una ventana llamada SET TABLE SIZE, que como puedes imaginar sirve para determinar el tamaño máximo de las coordenadas X e Y, que en nuestro caso son 16 en X, 128 en Y.

¿Por qué 16 y 128? Muy fácil, 16 son los beats que tendrá el arpegiador, en el eje horizontal X, y 128 son el número estándar de snapshots... con lo de las snapshots seguro que te has quedado fuera de juego xD, pero no te preocupes, todo a su tiempo.

Ahora, en la misma pestaña Function, establece el Stepsize en 1. Después, accede al menú de la tabla pinchando encima en el panel con el botón derecho y selecciona la opción Table Draw Mode (por ahora no nos meteremos con el resto de las opciones, que por otro lado están explicadas en el correspondiente manual de Reaktor). Por último pincha con el botón izquierdo en la parte superior de la tabla, siempre dentro de la zona de edición (en negro).

----------------------------------------------------------------------------

Me detendré a explicar lo que acabamos de hacer; puede que ahora te resulte un poco lioso pero, como siempre, un pizco de teoría es necesaria antes de verlo con un ejemplo.

Al establecer Stepsize en 1, en realidad estás haciendo lo mismo que con los knobs: decirle a Reaktor que la tabla solo admite valores en pasos de 1, y como los valores min y max son 0 y 1, pues obviamente la tabla solo tendrá dos valores: 0 y 1. Sin embargo, justo antes de todo esto has establecido el tamaño de la coordenada Y de la tabla en 128, y el de la coordenada X en 16, entonces ¿de dónde sale eso de 0 y 1?

Pues lo cierto es que antes le quité una coordenada a la tabla para que no te hicieras un lío ;) , en realidad la tabla tiene tres dimensiones... sí sí, aunque solo veas dos, en realidad tiene tres. Las dimensiones que se ven, aunque normalmente deberían ser la X y la Y, en este caso se llaman X (la misma de siempre, horizontal) y Value. La coordenada Y lo que hace es almacenar distintos “puntos” [X, Value], que son lo que has hecho al pinchar con el botón izquierdo: en tu tabla ahora mismo puedes ver quince puntos con valor 0 (serían [0,0], [1,0], [2,0]...[16,0] ), y uno con valor 1 (que sería, por ejemplo, [4,1] ). Si leyeras la tabla para X=1, la tabla devolvería un valor de 0, y así hasta que llegues al punto que has cambiado, donde devolvería un valor de 1.

Cuando te mueves por la coordenada Y lo que consigues en realidad es acceder a diferentes tablas que, hablando con más propiedad, conforman un sistema de diferentes ejes de coordenadas cada uno con diferentes puntos.

Para moverse por los diferentes ejes (la coordenada Y) hay que acudir a la barra de desplazamiento vertical (no te lo recomiendo, después es muy difícil volver a centrar la tabla y de hecho, en un momento desactivaremos las dos barras) o cambiar la coordenada desde la misma estructura usando las entradas RY y WY del módulo, por ejemplo mediante un simple knob.

Por otro lado, hemos activado el Table Draw Mode, y con esto preferiría no detenerme mucho, solo aclararte que el Event Table, como cualquier tabla, sirve para muchas cosas, no solo para que el usuario final la rellene con datos, también puede que sea el programador quien la rellene, por ejemplo para ahorrarse el cálculo de una función matemática o para mostrar datos generados por el ensemble. En estos casos puede que el programador (tú mismo) no quiera que el usuario final meta la mano en los datos, o simplemente que la interacción con la tabla no sea tal cual pinchando encima, para eso están los otros modos. Están descritos en el manual y no los vamos a usar, así que ahí queda para quien le haga falta y seguimos.

----------------------------------------------------------------------------

Verás que la tabla viene por defecto con unas barras de desplazamiento: no las toques. Como ya he dicho antes, son muy raras, no es que funcionen mal, pero la forma que tienen de funcionar no es el esperado y hasta podrías verte obligado a crear la tabla de nuevo. Vamos a quitarlas: ve a las propiedades de la tabla, en la pestaña View, bajo el título Size, verás dos “ticks”, uno como Horizontal y otro como Vertical: despuntea los dos.

¡Quita las dos barras aunque en la foto solo se vea una! ;)

7.4. CLOCK - TEMPO

Hechas las presentaciones pertinentes, vamos al meollo: el reloj del arpegiador, o como lo habrás visto más a menudo, el clock.

Primero lo primero: haz una macro donde meteremos todo el arpegiador, y nómbrala tal cual, Arpegiador, ya deberías saber hacer esto de sobra ;)

Dentro de esta macro, haz otra macro que se llamará Clock, coloca las dos macros en el panel donde te quepan, por ejemplo a la derecha, y empezaremos a trabajar dentro de esta última macro.

Veamos, con los conocimientos que ya tenemos de los eventos, vamos a intentar planear un poco el funcionamiento del reloj, paso a paso.

Lo primero que debe hacer un clock, es emitir un impulso (lo que en Reaktor sería un evento) a una velocidad seleccionable. Para el caso de un arpegiador esta velocidad debe estar sincronizada con los BPM del DAW que se esté usando, además hay ciertos estándar que debería cumplir, como medir la velocidad en 1/4, 1/8, 1/16, etc.

Por tanto, lo primero que necesitamos es un módulo que emita impulsos a una velocidad conocida y relativa a los BPM. Para eso vamos a usar el módulo Built-In Module->MIDI In->1/96 Clock, que como su nombre indica (como siempre) emite impulsos a una velocidad de 1/96 de los BPM (aquí entra lo que decía en la introducción sobre las diferentes formas de hacer un clock, también se puede hacer con un módulo que da la posición en compases en la canción, y con otro módulo que da el valor numérico de los BPM conectado a un oscilador, amén de otro módulo que permite elegir desde la estructura la velocidad de los impulsos; estos métodos son perfectamente válidos, todos tienen cosas buenas y malas; es cuestión de que, una vez te manejes con los eventos, los pruebes y elijas el que más te convenga). Añade el módulo.

Ahora tenemos que modificar esa velocidad de manera que el usuario pueda elegir la que quiera, para ello vamos a usar otro módulo que modifica la velocidad de un pulso que debes añadir también desde Built-In Module->Event Processing->Frequency Divider.

Este módulo divide la frecuencia del pulso que le llega por la entrada Trig, entre el número que le llegue por la entrada N, emitiendo a su vez un pulso a la frecuencia resultante de esta división, con un ancho de pulso de W, todo ello se resetea cada vez que le llega un evento positivo por la entrada Rst.

En cristiano: si al módulo le llega un pulso a 1 Hz y le conectas un 2 a la entrada N, el módulo soltará un pulso a 0,5 Hz (1/2); para N=3 el pulso resultante será de 0,33333... Hz; para N=4 un pulso de 0,25 Hz, etc.

Por tanto lo primero que hay que hacer es enchufar nuestro módulo 1/96 Clock a la entrada N, y una constante con valor 0,5 a la entrada W. Así tenemos un pulso fijo a una velocidad de 1/96, y el pulso que salga será perfectamente cuadrado, lo que facilitará todo cuando el pulso llegue a la tabla (recuerda siempre que aunque esté hablándote de “pulsos”, en Reaktor esto se va a traducir en eventos).

Ahora hay que añadir “algo” que permita elegir la velocidad, que irá conectado a la entrada N del Frequency Divider. Seguramente lo que primero se te ocurrirá será un knob con los valores típicos de 4, 8, 16, 32; o quizá unos botones con cada uno de esos valores... pero tengo otra propuesta. No sé si estarás de acuerdo, pero a mí me fastidian mucho los secuenciadores que solo permiten asignar un solo tiempo: o UNA negra (1/4), o UNA corchea (1/8), o UNA semicorchea (1/16), siempre solo UNA. Por eso, en este secuenciador yo tengo la posibilidad de cambiar eso, y además vamos a ver otro módulo nuevo ;)

Añade dos módulos Built-In Module->Panel->List (añade uno y duplica).

El módulo List te da la posibilidad de definir una lista de valores, que el usuario puede seleccionar desde el panel como si fuera un switch (revisa el capítulo 2.4 para los switch), y de hecho, si vas a la pestaña View de las propiedades verás que las opciones son exactamente las mismas.

Los valores se pueden definir en la pestaña Function de sus propiedades, en el título Entries (como ya te adelanto en la imagen), uno a uno, o bajo el título Value Generator que genera valores en el rango que le especifiques.

Lo primero que hay que hacer siempre es definir cuantos valores va a tener la lista, esto se hace en Number bajo el título Entries. Para la lista de arriba vamos a especificar 4 entradas, para la de abajo 13 entradas. No te olvides de renombrar ambas listas, pon el mismo nombre a las dos: Tempo.

Las listas envían un evento cuando el usuario elige una opción desde el panel. Las columnas Label y Value representan respectivamente la etiqueta que enseñará la lista en el panel, y el valor que enviará la lista al elegir el usuario dicha etiqueta. Si haces doble click en cualquiera de las dos columnas podrás cambiar el valor escribiéndolo desde tu teclado, es texto plano.

Bien, queremos definir una fracción, una división que pueda ser 1/4, 3/16, 2/1, cualquier posibilidad que se nos ocurra sin salirnos demasiado del estándar, así que para la lista de arriba (la que será el numerando de la división) pondremos valores (columna Value) de 1 a 4 y en las etiquetas (columna Label) pondremos lo mismo. La lista de abajo (el dividendo) es más peliaguda, hay que poner valores desde 1 hasta 96, normalmente cada valor debería ser el doble que el anterior, pero también en esto vamos a ir un poco más allá y vamos a añadir tripletes... mejor te enumero aquí los valores y los copias:

1

2

3

4

6

8

12

16

24

32

48

64

96

Acuérdate que en esta lista los valores y las etiquetas también son iguales, así que tendrás que ir dando doble click en cada etiqueta para borrar el jodío “entry” de cada una de ellas, y después pasar a poner los valores correspondientes en la columna Value, todo ello en las dos listas.

Y llegamos a un poco de teoría obligatoria, tendrás que hacer un esfuerzo matemático, si no lo entiendes puedes preguntarme directamente vía mp... o simplemente creértelo :P

En un primer vistazo, podría parecer que con dividir estos dos valores ya tendríamos el número por el que tenemos que dividir la frecuencia, y así sería si el pulso inicial fuera exactamente a la misma velocidad que los BPM, pero no es lo que tenemos: recuerda que el pulso inicial nos lo da el módulo 1/96 Clock, que ya da el pulso en 1/96, que corresponde a algo así como tresillos de semifusas... MUY rápido :P

Si nos limitamos a dividir, estaremos dividiendo este valor, 1/96. No dividiremos los BPM, sino los BPM/96. Por ejemplo, si eligiésemos 1/16, el resultado no sería 1/16, sería (1/96)/16, algo así como 1/1536 XD.

Obviamente no queremos esto. La solución es multiplicar por 96:

96*(1/96)=96/96=1 => (96*(1/96))/16=1/16

Y eso es lo que vamos a hacer.

Añade un módulo de división, conecta las dos listas en la misma posición en la que están, la de arriba a la entrada de arriba y la de abajo, abajo (cuidado con esto, si cambias la posición, cambias la división). Después añade un módulo de multiplicación, conecta la salida de la división a una entrada de la multiplicación, y una constante con valor 96 a la otra entrada (aquí no importa la posición en que lo conectes, el orden de los factores no altera el producto). Así mismo, conectarás la salida de la multiplicación a la, por fin, entrada N del módulo Frequency Divider. Mira la imagen si te has hecho un lío:

Si te has asustado con todo esto, por ejemplo por que las matemáticas no son lo tuyo, para, repásalo o incluso hazlo de nuevo, coje un papel y haz las matemáticas por ti mismo. Es un buen consejo, por que en realidad esto es lo fácil, lo estamos pasando lento, paso a paso, para tener bien clara la base y después no tener que volver atrás, así que tómate tu tiempo e intenta entender cada paso antes de seguir.

Tal como están, las dos listas no tienen muy buen aspecto en el panel, lo arreglaremos rapidamente. En cada una de ellas ve a la pestaña View de las propiedades, y en Style selecciona Menu, quita la etiqueta a la de abajo (deselecciona Show Label bajo el título Visible), y junta las dos etiquetas. Debería quedarte algo así:

7.5. CLOCK – COUNTER

Con lo que hemos hecho ya tenemos listo un clock simple que envía impulsos a un tempo determinado, sincronizado con el host del usuario... pero esto no basta para usar nuestra tabla de datos, que es realmente nuestro objetivo final: que el usuario introduzca los valores que quiere en la tabla, y que la tabla actúe de secuenciador cuando le de al play. Para conseguir esto tenemos que dar un paso atrás y fijarnos en cómo funciona el módulo Event Table.

Básicamente vamos a usar dos entradas del módulo: RX, y R. La entrada RX le dice a la tabla qué coordenada del eje X vamos a leer, y la entrada R ordena a la tabla que lea esa coordenada, y envíe un evento con el valor que tiene almacenado en ese punto.

Solo con esto, y recordando que Reaktor NUNCA puede enviar más de un evento a la vez, ya podemos sacar varias conclusiones:

1º La tabla necesita, antes que nada, las coordenadas que tiene que leer.

2º Estas coordenadas tienen que avanzar a cada paso del secuenciador, a la velocidad elegida en nuestras listas Tempo.

3º Una vez que las coordenadas hayan llegado a la tabla, hay que enviar un evento con cualquier valor a la entrada R, y entonces la tabla “soltará” el valor correspondiente.

----------------------------------------------------------------------------

Total, necesitamos que, a cada paso del secuenciador, llegue a RX el número de ese paso: el primer paso tiene que llegar 0 (por favor, siempre empezamos a contar en 0), el segundo paso será 1, el siguiente 2, y así sucesivamente. Resumiendo, Reaktor tiene que contar los pasos.

Teniendo como ya tenemos una estructura que emite eventos a cada paso, ya tenemos la mitad hecha: los eventos ya nos llegan, ahora hay que contarlos. Habrá que hacer otra estructura que vaya aumentando el valor de cada uno de esos pasos, un contador, o un “counter”, que es el nombre que veréis en las estructuras del 99% de los ensembles de Reaktor y que da nombre a este capítulo ;)

Sin embargo, tenemos un pequeño problema con nuestro contador, y es que sería muy fácil hacer un contador que sumara uno cada vez que le llegara un paso, el contador sumaría y sumaría y sumaría hasta el infinito, pero nuestra tabla solo llega hasta el paso 16, así que todos los valores a partir del 16 no nos servirían absolutamente de nada :P

Para resolver esto tenemos que aplicar algo de matemáticas, en realidad es bastante simple, dividimos el resultado del contador entre 16 y listo... va, no es tan fácil. El problema es que si dividimos entre 16 y ya está, no vamos a obtener los pasos enteros, si vamos por el paso 3 obtendremos 0,1875, y si vamos por el paso 751 obtendremos 46,9375.

Como te puedes imaginar, esto no nos sirve. Vamos bien encaminados, pero no es el cociente de la división lo que nos interesa, sino el resto de la división, es decir:

El resto es 15, ese es el paso del secuenciador que corresponde a 751, que es lo que nos interesa.

No estoy seguro de si la explicación matemática será suficiente para que entiendas por qué hay que usar el resto de la división. Si tienes una buena base matemática lo entenderás rapidamente, si no es así, tendrás que sacar tus apuntes de primaria o preguntarle a google: como siempre, estoy dispuesto a ayudar, pero fuera del tutorial, ya que no tiene que ver ni con Reaktor ni con sonido, y para explicarlo bien tendría que irme hasta la misma base de lo que es una división y qué es el resto, no es complicado, pero es largo y no cabe aquí. En cualquier caso, si les hiciera falta a muchos, bueno, ya veríamos, quizá valiera la pena hacer una especie de apéndice matemático, incluyendo esto... ya veremos.

Afortunadamente, hay un módulo que nos proporciona el resto de una división; igual que en otros lenguajes existe el operador módulo, en Reaktor existe el módulo Modulo :P . Basta de teoría y vamos a ello.

----------------------------------------------------------------------------

Haz una macro nueva dentro de Clock con nombre counter (ya que estás, vete a la pestaña View de las propiedades y ponla como no visible, o acabará dándonos el coñazo en el panel todo el rato). Dentro de counter añade los siguientes módulos que, a ojo de buen cubero, está claro que vamos a necesitar: una entrada a la macro, una salida de la macro, un Built-In Module->Event Processing->Counter, y un Built-In Module->Math->Modulo,x%y. Como vamos a tener más entradas a la macro, cambia el nombre a esta primera y llamala simplemente c, por que es la entrada por la que recibiremos el clock.

El módulo Counter será nuestro contador, cada vez que recibe un evento positivo por la entrada Up suma uno, cuando recibe un evento positivo por la entrada Dn resta uno, y cuando recibe un evento por la entrada Set sustituye el valor que va contando con el valor que le enviemos. Con lo cual, hay dos cosas claras: primero, hay que conectar el clock a la entrada Up, hazlo ya, por que no hay nada más que pensar a este respecto, está clarísimo; y segundo, usaremos la entrada Set para resetear el contador, aunque esto es un avance, el reset lo veremos en el siguiente capítulo, así que por ahora déjalo estar.

Ahora tenemos que hacer el módulo de cada evento que se ha contado entre 16, así que conecta la salida de Counter a la entrada A de Modulo (recuerda que en Modulo las entradas están posicionadas igual que si escribieras una división: el dividendo arriba y el divisor abajo; conéctalas en ese orden o le darás la vuelta a la división y estará todo mal), y como nuestro secuenciador tiene un número fijo de pasos, 16, a la entrada B hay que conectarle una constante con valor 16.

Verás que Modulo tiene dos salidas, la salida Div te da el resultado de la división sin decimales (vamos, redondeada), y la salida Mod es la que nos interesa, la que da el resultado normal del operador módulo que es el resto de la división, y la que vas a conectar a la salida de la macro.

Y tenemos listo nuestro contador. Si conectas la salida de esta macro a las entradas RX y R de la tabla, verás como funciona perfectamente, es el secuenciador más básico que puedes hacer.

De hecho, antes de seguir quiero que grabes el ensemble, y después lo conectes: solo tienes que añadir un salidas a las macros Clock y Arpegiador, enchufas la salida de counter a la salida de Clock, subes un nivel, enchufas la salida de Clock a la salida de Arpegiador, subes otro nivel y enchufas la última salida a las dos entradas de la tabla (ten en cuenta que la tabla no está conectada a nada, así que no está activa: para solucionarlo de manera provisional te recomiendo que añadas un módulo Numeric Readout, actives Always Active en su pestaña Function y enchufes la tabla al readout -quédate con el truco del readout, es muy útil cuando estás probando cosas, por que activas módulos sin tener que terminar la estructura-).

Dale al play y verás como Reaktor va pasando de un paso al siguiente de la tabla, y según va llegando a los diferentes pasos, va emitiendo eventos con el valor de cada uno de ellos.

Ya que estás, puedes jugar un poco con todo esto, prueba a cambiar los valores de la tabla y añadirle pasos, conviértela a mono y usa los valores para algo, por ejemplo para intentar usarlos como la gate del ADSR, lo que se te ocurra, sin miedo, que ya tienes grabado el ensemble... mola que Reaktor te haga caso ¿eh? XD

7.6. CLOCK – RESET

A todo esto, como no hay mejor aprendizaje que el que viene acompañado de diversión ;) , mientras has estado toqueteando el secuenciador a tu bola, espero que la metáfora de la carretera que te expliqué antes se te haya quedado bien grabada. Cuanto te expliqué esta metáfora te decía que los eventos son como mensajeros por una carretera de un solo carril; antes de continuar, vamos a seguir la pista al mensajero que hemos creado.

Los mensajeros (los eventos) se crean en el módulo 1/96 Clock, llegando al módulo Frequency Divider. Este último módulo tiene una única función: variar la velocidad de los mensajeros, que siempre llegan a razón de 1/96 de los BPM. Frequency Divider los retiene, van amontonándose según llegan, y el módulo los deja salir uno a uno según el tempo que el usuario le indique.

De ahí entran a la macro counter, donde el módulo Counter se encarga de irlos contando. Estos eventos paran su viaje aquí, y cada vez que llega uno, Counter envía un evento nuevo que lleva un mensaje con su número: cuando llega el primero sale otro con el número 1, cuando llega el segundo sale otro con el 2, con el tercero sale otro con el 3, y así sucesivamente. Los eventos que llegaban a Counter también llevaban un mensaje, un valor, pero como no lo usamos para nada, nos da igual, lo que nos importaba es que llegasen y activasen la cadena de eventos.

De Counter los mensajeros van llegando a Modulo, quien divide el mensaje (el valor) entre 16, calcula el resto de la división y vuelve a enviar otro mensajero con dicho resto. Y estos eventos son los que, finalmente, salen de la macro y llegan a la tabla, donde entregan su mensaje, la tabla lee el dato correspondiente al mensaje y a su vez envía otro mensajero con ese valor...

Hasta aquí todo ha sido muy limpio, solo tenemos que enfrentarnos a un evento a la vez, todos los eventos están ordenaditos, van llegando uno a uno y son contados, clasificados, dirigidos y controlados según van llegando, por orden y sin problemas.

Nos falta, sin embargo, algo que indique a Reaktor cuando termina y vuelve a empezar todo este tinglado: un reset. Esto nos dará más de un problema, aunque no será nada que no podamos resolver ;)

Antes de seguir, si no lo ha hecho ya, carga el ensemble que guardaste antes de ponerte a toquetear el secuenciador, y seguimos a partir de ahí. Lo primero que hay que hacer es conectar la salida del Frequency Divider a la entrada de c de nuestro contador.

Y seguimos: supongo que ya sabrás que Reaktor tiene un play-pausa y un stop.

Si abres Reaktor en un DAW cualquiera, estos botones desaparecen y sus funciones son ejecutadas por los respectivos del DAW en cuestión.

Bien, pues existe un módulo que te permite saber desde la estructura, cuándo el usuario da al play o al stop, que por razones obvias resulta perfecto para resetear nuestro secuenciador, y vas a añadir sobre la marcha desde Built-In Module->MIDI In->Start/Stop.

Tal y como explica la info del módulo, la primera salida del módulo, G, es una gate que se abre (valor 1) siempre que el play “está activado”, es decir siempre que la canción se está reproduciendo; la segunda salida, Rst, emite un evento con valor uno siempre que se para la canción, y está pensada precisamente para resetear secuenciadores.

Usaremos el módulo para dos cosas: primero, resetearemos el Frequency Divider cada vez que el usuario le de al play, así nos aseguraremos de que todo comienza de nuevo y está perfecto antes de que se reproduzca; segundo, usaremos la salida Rst para resetear nuestro contador.

Para ello nos faltan dos cosas, primero tienes que conectar la salida G del Start/Stop a la entrada Rst del Frequency Divider. También tenemos que enviar al contador la salida Rst, y para ello tienes que hacer una entrada en la macro, que llamaremos a su vez rst, conectando ambas.

Ya tenemos dentro de la macro counter una entrada que nos facilita un evento cada vez que el usuario hace stop, si conectamos este evento a la entrada Set del módulo Counter, nuestro contador se reseteará con el stop del host. Sin embargo, antes de seguir me gustaría que leyeses la info de la salida Rst y la entrada Set (recuerda que si está activado el botón “i” de la barra superior de Reaktor, al dejar el puntero del ratón encima de un módulo, se despliega la info de ese módulo, recuerda también que las entradas y salidas también son módulos).

Voy a traducir las dos aquí:

Para la salida Rst: Esta salida envía un evento con valor 1 cuando el reloj (se refiere al reloj interno del host) es reseteado hasta ser 0, o cuando se reproduce la canción desde la posición 0. La salida se usa para resetear secuenciadores, etc.

Para la entrada Set: Un evento en esta entrada iguala la salida a su mismo valor.

Es decir, que tal y como lo tenemos conectado ahora mismo cuando el usuario le de al stop, por la salida Rst saldrá un evento con valor 1. Este evento entrara en la macro y llegará a la entrada Set, que establecerá el contador en su mismo valor, que es 1, y además enviará un evento con dicho valor.

Tenemos dos problemas:

1. La tabla empieza a contar desde 0, no queremos que se resetee con valor 1
2. Cuando reseteemos, el módulo Counter enviará un evento con valor 1.

No sé si te has dado cuenta, pero el evento del punto 2 es igual que cualquier otro, desencadenará toda la sucesión de eventos que hemos visto al principio del capítulo, llegando hasta la tabla y, cuando la tabla esté conectada, hará que el sinte emita una nota cuando reseteemos. Si bien esto no hará que el arpegiador no funcione, es MUY feo, cutre... ¿cada vez que tengas que darle al stop sonará una nota...? No puede ser, hay que capar ese evento. Lo arreglaremos, pero antes vamos a ver el punto 1.

Esto es lo que pasa si seteamos el contador con valor 1:

Si el contador se resetea con valor 1, cuando el usuario le de al play el contador ya tendrá establecido el valor 1, le llegará el primer impulso de nuestro clock, y el contador sumará 1 al valor que ya tiene, con lo que el valor que saldrá será 2.

No me mires así de extrañado xD, recuerda el repaso de la cadena de eventos que hemos hecho al empezar el capítulo: SIEMPRE que al contador le llega un evento por la entrada Up, suma 1. Si tú estableces el valor del contador en 1, y después le mandas un evento a la entrada Up, el valor que tendrá el contador será 1+1=2. Con lo cual, después de resetear, el primer paso que lea la tabla no será el paso 0 (recuerda que hay que empezar a contar desde 0), ni siquiera será el paso 1, el primero que lea será el paso 2... un desastre :P

Para arreglar esto seremos más listos que Reaktor, que para algo Reaktor solo hace lo que le dicen: sabemos que el primer impulso del clock va a sumar uno al valor que hallamos establecido en el contador, y queremos que el resultado de la suma sea 0, para que la tabla lea su primer paso, por tanto 0-1=-1. Qué fácil era ;) , solo hay que cambiar el valor del evento, de 1 a -1.

Como no podemos meternos dentro del módulo Start/Stop (ni dentro de la mayoría de módulos), NI ha hecho un módulo específico para cambiar los valores de los eventos, que vas a añadir sobre la marcha desde Built-In Module->Event Processing->Value.

Cuando el módulo recibe un evento con cualquier valor en su entrada Trig, envía otro evento con el valor de su entrada inferior.

Fijate que la entrada inferior es de audio, y la de arriba de eventos. Esto está hecho así a conciencia, ya que puedes mandar cualquier valor en cualquier momento a la entrada de audio, y como es de audio, ese valor permanecerá ahí a la espera de ser llamado por la entrada superior, que es de eventos, y por tanto solo funcionará cuando le llegue un evento, de esta forma te aseguras que la cadena de eventos no se rompe, y cambias el valor del evento.

Dicho lo cual, hay que conectar nuestra entrada rst a la entrada Trig, a la entrada inferior del módulo hay que enchufarle una constante con valor -1, y la salida del módulo hay que enchufarla a la entrada Set de Counter.

Cosas como estas te pasarán cada dos por tres: eventos que se repiten, eventos que traen un valor equivocado por no leer la info de un módulo, eventos que llegan en un orden o en un momento que a algún módulo cojonero no termina de gustarle. Los módulos del menú Built-In Module->Event Processing te ayudarán a corregir estas “desavenencias” entre módulos, si vas a hacer ensembles medianamente complicadas tienes que saber cuándo usarlos, por supuesto, pero lo más importante es que tengas claro qué está pasando en tu ensemble, por que si no, cuando algo falle, no serás capaz de localizar el problema.

Ten en cuenta que cuando yo hice este secuenciador por primera vez, no sabía nada de lo que te estoy contando, no me di cuenta de que Start/Stop lanzaba el evento con valor 1 hasta que no lo conecté todo, le di al play, y la tabla empezó a leer en el paso equivocado. Cuando el error “salta”, tienes que volver atrás y buscarlo, si no tienes una idea clara de qué está pasando, y lo tienes todo ordenado con sus macros y sus nombres, buscar un fallo de este tipo es como buscar una aguja en un pajar.

Bien, en algún momento tenemos que probar lo que hemos hecho, así que vamos a aprovechar y dejar todo lo que hemos hecho operativo. Para ahorrar un poco de espacio y tiempo te voy a decir unas cuantas cosas de golpe, y después te pondré unas fotos para que compruebes si lo tienes bien: nos falta una salida de la macro clock, una salida en la macro Arpegiador, corta la tabla y pégala dentro de la macro Arpegiador. Conecta la salida de counter a la salida de Clock, subes un nivel, conectas la salida de Clock a las entradas R y RX de la tabla, y la salida de la tabla a la salida de Arpegiador.

Hay algo que nos falta en esta macro, y es que la tabla (y algún módulo más) está en polifónica. Esto no es necesario, ya que tal como lo hemos construido, la tabla solo puede generar una nota cada vez, y además nos puede dar un montón de problemas después, precisamente por que no hemos preparado nada para que sea polifónico y sin embargo, el resto del sinte es polifónico.

Recuerda que si conviertes a mono una macro, todo lo que contenga esa macro incluidas submacros y todo lo que estas contengan, se convertirá también en mono. Hazlo así para asegurarte de que todo quede en mono: sal de Arpegiador, selecciona la macro y conviértela en mono.

7.7. DE EVENTO A GATE

Prepárate, este capítulo tiene chicha de la buena.

Tenemos que salir de esta macro e irnos a la macro ADSR. Puede que te hayas quedado un poco flipado con esto, pero piensa qué debe hacer nuestro arpegiador: generar una gate. No genera pitch por que no lo hemos preparado para ello, genera eventos de valor 1 y 0, cuando esos eventos tienen valor 1 debe sonar una nota, cuando tienen valor 0 debe dejar de sonar: una gate.

¿Dónde está la gate de nuestro sintetizador? En la macro ADSR, justo antes del módulo ADSR que genera la envolvente.

Claro, lo que hicimos en su momento (capítulo 2.2) fue conectar la gate que funciona vía MIDI al módulo ADSR, para que la envolvente se activara con los mensajes MIDI “note on” y “note off”. Totalmente correcto, pero ahora, además de eso, queremos que la envolvente se active con los eventos que envía nuestra tabla. Y subrayo además, por que podríamos conectar la tabla directamente al módulo ADSR, igualito que está conectado ahora el módulo Gate, pero entonces el sinte SOLO funcionaría con la tabla, y esa no era la idea.

Tampoco deberíamos sumar, esto no es una señal de audio, y quizá en este caso no plantearía problemas, pero no es bueno acostumbrarse a usar la suma para estas cosas cuando trabajamos con eventos, podría alterar el orden de los eventos y estropear la cadena, cosa que no queremos, queremos que los eventos de la tabla pasen a ADSR cuando lleguen de la tabla, y que pasen los de Gate cuando lleguen los de Gate: ni antes ni después, en su momento.

Lo adecuado en estos casos es el módulo Built-In Module->Event Processing->Merge, que tiene muchas entradas solo válidas para eventos, y deja pasar los eventos a una sola salida en el momento y orden en que lleguen: sin importar a qué entrada estén conectados, salen en el mismo orden que entran (típico orden FIFO).

Ya dentro de la macro ADSR, añade el módulo Merge y una entrada. Inicialmente el módulo Merge solo viene con una entrada, lo puedes cambiar desde la pestaña Function, o usar un truco que creo no había comentado en el tutorial, y sin embargo aparece en uno de los blogs del compañero hispasónico Ardot Adot (que por cierto puedes ver en esta web desde el menú Comunidad->Blogs o buscando su usuario... recomendados si te interesa la síntesis granular y cualquier otro método de síntesis de “destrucción de samples”... gracias por el recordatorio :P ) que es presionar la tecla ctrl al mismo tiempo que arrastras el ratón hacia el módulo, fíjate en la foto:

Y listo, solo te queda salir de la macro, y conectar la salida de Arpegiador a la entrada que acabas de hacer en ADSR. Lo mejor sería que aprovecharas para colocar la macro Arpegiador al lado de ADSR, y para colocar la tabla en el panel, que se habrá quedado descolocada.

Ahora que podemos probar el arpegiador, si le das al play verás que se oye algo raro, es como si sonara más de una nota, y efectivamente es eso, el problema es que tenemos el sintetizador en polifónico y cuando el evento llega al merge, se disparan todas las voces juntas. Puedes verlo si activas el botón de debug y dejas el puntero del ratón encima del cable entre el módulo Merge y el módulo ADSR.

Como puedes ver en la foto, el botón con el icono de una cucaracha (bug en inglés es cucaracha) debe estar activado, así como el botón de info con el icono de la “i” aunque no salga en la imagen (lo siento, no cabía :), si los dos botones están activados, al dejar el puntero del ratón encima de un cable, se muestran en un recuadro el valor de todos los eventos o audio que están viajando en un momento dado por dicho cable. No es muy preciso, de hecho es muy poco preciso, pero sirve para hacerte una idea.

En nuestro caso, teníamos el sinte con 4 voces, que puedes ver en el recuadro numeradas del 1 al 4, y por cada voz debe ir un evento determinado que activa la envolvente para esa voz. Lo que está pasando es que, aunque el evento que llega de la tabla es monofónico, el módulo Merge es polifónico, y como no hemos especificado otra cosa el módulo entiende por defecto que ese evento debe repetirse por cada una de las voces, mandando un evento POR CADA VOZ, igual al que le ha llegado. Esto activa la envolvente para todas las voces al mismo tiempo, y tiene ese efecto que has oído.

Podrías pensar que si hubiéramos dejado el arpegiador en polifónico, ahora no pasaría esto, que todo habría cuadrado con normalidad, pero no es así. Si hubiéramos dejado el arpegiador en polifónico, vete a saber por qué voz viajaría el evento, y qué voz activaría la envolvente. El arpegiador no está preparado para trabajar en polifónico, no sabemos lo que pasaría, así que pasarlo a polifónico no es la solución correcta.

El módulo Merge debe quedarse polifónico para soportar la gate MIDI que, obviamente, también es polifónica, así que también podemos descartar esa solución... y es tiempo de presentar otro módulo, llevamos unos cuantos en esta entrada, espero que no te hagas un lío.

Lo que nos hace falta es el Built-In Module->Auxiliary->To Voice, que como su nombre indica, envía un evento a una voz determinada que puedes elegir desde la estructura.

Con este módulo enviaremos los eventos que lleguen de la tabla por una sola voz, y por tanto la envolvente solo se activará en esa voz. Sin embargo, una vez lo añadas y vayas a enchufarlo (obvio, la entrada V es la voz a la que quieres enviar, la otra entrada es el evento, parecido al Value que ya vimos antes), pregúntate antes a que voz vas a mandar el evento.

Los instrumentos polifónicos de Reaktor van usando las distintas voces según va recibiendo datos MIDI, la forma exacta en que asignan los distintos pitch y gate a las diferentes voces se puede cambiar desde las propiedades de cada instrumento, pero es una información a la que no puedes acceder desde la estructura. Por tanto, sería una locura montar una estructura para intentar adivinarlo, para serte sincero no sé ni si sería posible. Pero hay un truco que descubrí haciendo “ingeniería inversa” (hazla siempre que puedas) a algunos instrumentos que vienen con la librería de Reaktor, y que puedes ver tú mismo buscando una macro que se llama siempre Last Voice.

Te pongo una foto de la susodicha macro:

Me gustaría que antes de seguir hicieras una igualita dentro de la macro ADSR. Ya sabes donde encontrar el módulo Value, así como la salida de la macro; te hacen falta otros tres módulos: Built-In Module->Auxiliary->Voice Info, Built-In Module->Auxiliary->Event V.C. All, y Built-In Module->MIDI In->On Velocity. Conéctalos tal y como están en la foto y te explico de qué va el asunto.

El módulo Voice Info da información acerca de las voces del instrumento, cada salida da una información distinta. La que se está usando en este caso, V, envía un evento polifónico, que tiene un valor igual al número de la voz por el que viaja: si va por la primera voz, tiene un valor de 1, por la segunda voz con valor de 2, etc. Fíjate que esto está conectado a la entrada de audio de Value (si no recuerdas como funciona este módulo, sube un poco, hasta el capítulo del reset de esta misma entrada), es decir, estos valores serán los enviados cuando llegue un evento a la entrada Trig.

El módulo On Velocity es como el módulo Gate, pero para la velocidad MIDI, simplemente envía un evento con el valor de velocidad MIDI por la voz correspondiente.

El Event V.C. All, el último módulo, envía un evento por cada voz por el que recibe otro evento, todos con sus correspondientes valores originales, y todos monofónicos. Es decir, convierte un evento de polifónico a monofónico a lo bruto, enviando uno detrás de otro todos los eventos de todas las voces.

Será mejor ponerte un ejemplo. Imagina que presionas una tecla de tu teclado MIDI con velocidad 100. Reaktor recibe el mensaje MIDI, y lo asigna a la voz número 3. El módulo On Velocity envía un evento con valor 100, por la tercera voz, y ese evento llega al módulo Value POR LA TERCERA VOZ, por las otras voces no le llega ningún evento. El módulo Value va a lanzar un evento con el valor que tiene grabado en su entrada de audio, pero está en polifónico y le ha llegado un evento en polifónico por la tercera voz, así que cojerá solo el valor de la tercera voz, que es 3.

Si te digo la verdad, no sé por qué voz enviará Value este evento, en pura teoría debería enviarlo por la misma que le ha llegado, pero a saber, la cuestión es que en las otras voces no hay evento, y llegamos al módulo Event V.C. All, que como solo hay un evento con valor 3, solo mandará un evento monofónico con valor 3, que, POR FIN, es el valor de la última voz usada por Reaktor... Dios, me hace falta un emoticono para “volverse loco”.

Es una forma muy ingeniosa, aparentemente simple por que tiene una estructura muy simple, de saber cual es la última voz usada sin tener que hacer una mega estructura para intentar adivinar cómo está regentando Reaktor las voces. Una macro simplita, apenas sin consumo de CPU, y listo.

Vale, una vez te lo he explicado (no digo “lo has entendido” por que la cosa tiene guasa, tómate tu tiempo), ya tenemos la voz a la que tenemos que enviar nuestro evento de la tabla, así que conectémoslo todo.

Tenemos nuestro arpegiador funcionando excepto por un par de errores: cuando reseteas se queda sonando el último step del arpegiador, y si paras el arpegiador en un step que tenga 1 este se queda sonando hasta el infinito.

Vamos a arreglar el primer problema, y el segundo voy a dejar que lo arregles tú ;) . Te adelanto que tendremos que arreglarlo desde la macro counter, en Arpegiador->Clock->counter, así que vete situándote en esa macro.

La causa del problema es fácil de averiguar: ¿recuerdas que cuando reseteamos establecimos el valor de nuestro contador a -1? ¿y recuerdas que el contador enviaba ese -1 como un evento? Pues ese es el problema, al hacer la operación módulo -1 el resultado es 15 (puedes comprobar la operación con la calculadora de windows, con el botón “Mod”), ese 15 está llegando a la tabla, que lee el paso 15, que es el último.

Como controlamos perfectamente nuestra cadena de eventos (jeje ;), sabemos sin duda que el único evento con valor -1 que puede generarse es precisamente el del reset. Por tanto, es tan fácil como no permitir que pase ningún evento con valor -1, y para eso llegamos al último módulo que te voy a presentar en esta entrada, el Built-In Module->Event Processing->Separator, ya lo estás añadiendo a la macro.

Este módulo es como un if de toda la vida, una comparación, solo que redirige los eventos a una salida u otra. Si In es mayor que Thld (threshold, umbral), el evento que le llega sale por la salida Hi (higher, mayor), y si es menor o igual el evento sale por Lo (lower, menor). Así de fácil.

Queremos comparar el evento que sale del Out del módulo Counter con -1, así que a la entrada Thld hay que conectarle una constante con valor -1, y a la entrada In hay que conectarle la salida Out de Counter.

Claro que el valor -1 sí tiene que llegar a la tabla, por que es un valor que no hará que la tabla lea, pero sí la dejará en la posición que nosotros queremos para resetear el arpegiador... si no has terminado de entender esto último te sugiero que conectes todo y lo pruebes tú mismo, lo verás mejor.

¿Lo ves? ¿Has visto cómo ahora cuando reseteas, la barrita verde que indica qué paso está leyendo la tabla se coloca en el último paso, y sin embargo la tabla no envía el evento que activa la envolvente? Eso es lo que buscábamos, situar la tabla en su sitio sin enviar un evento: en el paso 15, que es el que se activaba antes, la tabla tiene un valor específico que puede leer; en el paso -1 no existe ningún valor, el lector se coloca en el paso 15 por que si vas hacia atrás desde el paso 0, “visualmente” el paso que le toca es el 15, si lo hubiéramos reseteado con valor -2 habría acabado en el paso 14... sin embargo no lee el paso 15, intenta leer el paso -1 y no existe, así que no hace nada más.

Y con esto doy por acabada esta entrada y el tutorial: los osciladores quedan funcionando, la envolvente funcionando, el filtro funcionando, el “amplificador” funcionando, el arpegiador funcionando salvo un pequeño problema que os lo dejo como últimos deberes... aunque como el tutorial se acaba aquí, os lo dejo más bien como exigencia, trabajo y acicate a vuestras creatividad y ansia de conocimiento, y bueno, a vuestro aburrimiento en más de un caso, estoy seguro ;)

Finalmente el tutorial queda completo. Es una espina que tenía clavada hace mucho tiempo, queda poco para que hagan dos años de la última entrada, y aunque este tipo de tardanzas no me gustan nada de nada, os diré que en estos dos años me han pasado muchas cosas, problemas y problemas, qué os voy a contar a vosotros, tal y como están las cosas... entre otras cosas de mayor o menor importancia, desde mayo del año pasado fallecieron mi padre, mi tía (su hermana), y para rematar, mi perro.

En fin, han pasado muchas cosas, así que espero que sepáis disculpar la tardanza dado que la Picha ha sido buena xD Queda también repasar las entradas anteriores, ya que entre mi manía de no escribir las entradas directamente en el blog y los cambios de hispasonic, el formato ha desmejorado mucho del que yo tenía planeado... quizás dentro de otros 2 años XD

Y bueno, como algo a medias entre una pequeña disculpa y un pequeño agradecimiento por seguir los tutoriales y todos los comentarios que habéis hecho (aunque no haya respondido a muchos os aseguro que los he leído todos, y podéis creer que son lo que me han dado ánimos para terminar esto), os dejo un link para la macro del secuenciador del que os hablaba al principio de la entrada, pero actualizada y con bastantes más opciones, la que yo uso ahora mismo en casi todos los ensembles para testeo o directamente para modificarla y crear lo que más me convenga. Tenéis permiso expreso para estudiarla, modificarla, destrozarla y hacer lo que os de la gana con ella ;) , aquí va el link: https://app.box.com/s/oyb9o726xxpgcputo22b

Un saludo a todos y, como siempre, experimentad.