Modular version number 1 ( the first that worked when reassembled)
In the continuation of the previous experiment, i developped less the "robot" aspect, and tried to give more settings to configure for the users so that it's less playing a certain music by itself with many variations on its own, but rather improvise music in a range that is narrowed by user, such as random rythm or defined rythm, and possibility control more precisely what is playing what and when.Part of the reasonning being that many instruments could reuse part of the same logic, so i attempted to make the original machine into distinct modules that could be easily added or removed from the core machine, to add instruments and vizualize what's happening better.
What is presented here is not in a "final" state, it shows steps of progressions that i have built enough upon afterwards that i think it was a good decision to try this and wanted to share some progress, i'm open to feedback positive or negative
.Here is an overview of the machine re-assembled :
- Assembled.jpg (4.94 MiB) Viewed 1184 times
It look quite similar to the previous one and it works surprisingly, i was not sure it was a good idea to attempt reorganizing everything. Sometimes i can't put everything back together, but this time it worked. It was made from many different modules that successfully reconnected when pasted together :
- clock & counters.jpg (174.73 KiB) Viewed 1184 times
This part is the base of the machine, the clock signal is sent everywhere to sync the music. This part also provide the random number for the other modules that require it. It also provide a signal of activation. It also provide a signal that count how many repetition occured keeping track of time for other modules that need it.
All the constant combinators containing "OUT" visible on it are turned off, they are used for routing signals, This is the clock, it's not receiving any signal, instead it's only "OUT".
This is also the part that contain the play/pause button.
Here is how it look when it's connected to the bus that transmit signals in other modules :
- clock plugged in.jpg (289.07 KiB) Viewed 1184 times
Here is the second module :
- RNG to Note.jpg (174.01 KiB) Viewed 1184 times
This part receive some signals from the other modules through the plug "in R", that is for the random number coming from the clock module, in SE represent the connextion by which "settings" are received to handle the transformation of the random number into different notes. The signal "in green" is used to receive synchronization signal from other modules.
This part output signals " out N" which is the root note, dealt with by the upper part, and "out 0-7", which will be the different notes from the bottom part of that modules.
This is also the part where the "autotune" is active, current version shows the C major scale, but i have also made little variations that can play different scale like F#major, and only using #notes, it require little adaptation but it sound good.
Here is another module and an illustration of what is easy to do once it's made into little module :
- note memory.jpg (302.19 KiB) Viewed 1184 times
- note memory 2.jpg (391.19 KiB) Viewed 1184 times
The first version is just a very compressed version of the original block of 12 memory cells, with the same treatment for input and output signals dealt with a "bus". The fact that's it's a "module" or a "patch" they say in video about modular synthetizer that's i've watched for inspiration makes it easy to customize it with some buttons or display to show which cell of the memory block is accessed, and what is its content. This additionnal display part is not necessary for the machine to function, is not connected to the main bus of signal, it's just reading part of what this module is sending to main "bus of signals", intercepting the signal as they are sent to the main bus.
This part alone doesn't make much sense though, i realized when attempting to rebuild other machines, in such state it works only when another module is also present, such rules being annoying i remade the 2 modules that can't work on their own into a single module that will be displayed later. Such version was working though.
Here is the other module required for this one to function :
- settings for note.jpg (1019.13 KiB) Viewed 1184 times
It was not even placed next to the correct one in the version pictured at first, it is the module where manual settings for the range allowed of randomness for each note is choosen manually.
There are 4 groups in this version, so it is possible to set up 4 different pattern of notes, supposedly one for the chorus, one for arpeggio, one for tremolo, and one for whatever sound pleasing, each time it's choosing 8 range that are allowed compared to a root note choosen in the "RNG to note module". That also is not ideal that's why it's wip. 4 group of patterns, and 3 version of each are stored in memory, that makes it 12 cells, that's the 12 lamps in the previous modules, each cell having 8 values, displayed when they are accessed. Those value are the pitch of the note basically, so 42 would correspond to note 42 in the list. And the settings works by selecting +5 -6 let's say, on a "root note" that if is 40 would yield notes either 34 or 35 or 36 .... 45, but then if it's not a note in the choosen scale it's modified to the next note of higher pitch that is in the choosen scale.
It receive the green signal for synchronization from the clock at the same time as the memory that will store the notes after the RNG is modified by those settings. This allow all modules to stay synchronized no matter where they are located on the machine, as long as they have direct connection to the signal bus. This kind of organisation works really well i found, and i'm not very good at organizing usually, so i need method that are efficient and easy. I can only recommend x).
The next "logical" step for the machine is done by this module :
- memory decoder.jpg (453.45 KiB) Viewed 1184 times
This is the place that will assign the 8 original notes values obtained through previous process into 32 notes to play sequencially, the diferent notes could be stored as :
signal 0 : 32
signal 1 : 30
signal 2 : 28
signal 3 : 26
signal 4 : 24
signal 5 : 20
signal 6 : 24
signal 7 : 18
That would be contained in 1 memory cell, but when played, this module will assign
note 1 : signal 0
note 2 : signal 1
note 3 : signal 2
...
note 8 : signal 7
note 9 : signal 7
note 10 : signal 6
note 11 : signal 5
note 12 signal 4
...
note 16 : signal whatever you prefer
...
note 32 : last note why not pick the note of the 8 that is the lowest ?
Not sure the explanations is very good, roughly it will always do the same things regarding the 8 different pitch value given to it, but it will yield 32 notes in total, which means some of them will repeat. The repetition that this couldd create is hidden using other modules.
In the latter version i'm attempting to make many of those modules "per instrument" but so far, in this presented version, the output of this memory decoder is sent to the signal bus and every instrument plugged will read the same notes at the same time.
This allow to have the piano and the vibraphone playing the same note if wished, and it's possible to have the vibraphone play only half the notes, or the opposite, why not, since instrument are different modules , it is possible to do modifications on the particular module.
Here is another module :
- Rythm plugins.jpg (741.34 KiB) Viewed 1184 times
This one is receiving a random number through the bus channel from the clock, and it can be used to determine when the note will be played, since random numbers are 32 bits, the randomizer when creating a random 32 bit number will then have the instrument only play when the bits are 1 ( or 0 ), half of the time on average, but with some acceleration and slow down.
This pluggins also allow to forget about the randomness and instead use rythm manually inputed, one can turn off the combinator that hold the red color to instead use the lamp pattern as rythm. This was a small version so it's only possible to choose a 8 bit number as the rythm, and then it's made into a 32 bit number where the original 8 bit pattern repeat 2 or 4 times. When only 2 there are silences, it's slower music.
This is the plugin that made me want the most to have things working "per instrument", instead of having one of such module and customizing instrument modules afterward, rather embed the rythm plugins in the instruments. ( Shown later maybe x) ).
This module is not functionning on its own, that again a mistake coming from that very early version, it require another module to synchronize properly the notes and the random/choosen rythm coming from this module. It look like this :
- beat and note synchronize.jpg (980.81 KiB) Viewed 1184 times
This module is also used to extract some display information since its output is synchronized for the speaker to play from its output, it was the proper place to do i thought. But in later version i just removed the rythm module and the synchronizer and instead embedded them with the instruments. It feels easier to use, each instrument can have its own rythm. But in this version it is the module that output the content for the "screen". It means it's also where colors are codded for display of notes in its own lamp that helps follow what's going on too.
Its main role though is to shift the number that represent the rythm by the moment in the music, and detect if the beat is 0 or 1 to then let the note goes through or not. That was not done in the previous module, only the creation of the number. This one thus receive the rythm number ( the yellow channel ), but it also manage when the rythm is made into "random" the reseting memory cell that update a new random number as base for the rythm. thanks to the cyan channel. The notes coming from the D for decoded channel.
At this point there are already 10 pictures attached in this post, so the next modules will have to go in the next post.
