Algorithmic Music in a Box

Algorithmic Music in a
Box
wesen - Manuel Odendahl - http://ruinwesen.com/

Algorithmic Music
• Producing electronic music for the last 3
years
• Background in programming, hacking
• Learnt electronics on the fly
• Interested in building MIDI controllers
• Microcontroller programming

In a Box
• First MIDI controller
• Big clunky wooden box
• Dozens of pots that
would break once a
week
• USB MIDI: 2 Atmels

Hardware Synthesizers
• Later on moved from computer production
to hardware
• Focus on more minimal ideas
• Hardware has its limitations
• 4 keypresses to access the delay on the
Elektron MachineDrum

Elektron Controller
• Special midi controller:
• 4 pots, MIDI out, just to control the delay
• Completely new possibilities by “hacking”
existing synthesizers
• Reading internals, MIDI implementations
and working around the limitations

Ruinwesen
• New design of the controller, allowed to
hack around a lot of limitations of the
MachineDrum and MonoMachine
• Decided to start a company building digital
and analog hardware with Ruin from
Canada

MidiCommand and
MidiDuino
• Evolved from the idea of a simple
controller to a custom programmable
opensource controller inspired by the
Arduino
• Integrated the MidiCommand and the
RuinWesen microcontroller code into
Arduino environment

Midi Hacking
• This is where the fun starts!
• Thoroughly interested in musical theory
and “flow”
• How can hardware, even with simple
controls, be used to change the way we
think about music

Midi Hacking
• A lot of musical “concepts” have their roots
in mathematics and algorithms
• Exactly the right spot to merge hacking
ideas and musical ideas, exploring concept
both “artistically” and on the code level
• Amazing how for example techno mirrors
traditional music

The MIDI Protocol
• Published in 1983
• Serial link with 31250 bps
• 2 separate cables: IN and OUT
• Current loop: information is exchanged by
current (to avoid ground loops)

The MIDI Protocol
• Information is encoded in bytes
• Use of MSB as status flag:
• 0 - 127: data byte
• 128 - 255: command byte
• Easy in-ligne signaling of commands

MIDI Protocol
• The lower nibble of MIDI commands
indicates the selected MIDI channel
• 16 MIDI channels multiplexed on one
cable
• Devices can listen on a specific MIDI
channel or on all channels (omni mode)
• Sysex and realtime messages have no
channel

The MIDI Protocol
• Music oriented commands:
• Note On, Note Off, Controller Change,
Program Change, Aftertouch
• Realtime Commands: Clock, Start, Stop
• Sysex (general data)

MIDI Commands
• Note 60 On Velocity 100 (channel 0): 0x90,
0x3c, 0x64
• Controller 30 Value 10 (channel 4): 0xB4,
0x1E, 0x0A
• Sysex with bytes 0x00 0x23 0x35: 0xF0
0x00 0x23 0x35 0xF7
• have to encode 8 bits data in 7 bits

The MIDI Protocol
• Three kinds of MIDI devices:
• Mostly receiving data: synthesizers
• Mostly sending data: sequencers, midi
controller
• Most devices support system specific
functions using Sysex messages with a
proprietary format

The MIDI Protocol
• MIDI can be connected to a computer
using a MIDI interface: soundcard, USB
MIDI device
• MIDI can be chained
• most devices have a MIDI Thru which
mirrors the input
• using custom MIDI hubs and mergers

MidiDuino
• Integration of RuinWesen MIDI controllers
with Arduino
• Custom MIDI and USB MIDI bootloader
• Lots of MIDI functionality integrated for
easy use

MidiDuino
• Based on Atmel CPUs
• Libraries written in ASM, C and C++
• ASM for “voodoo” time-critical stuff:
• parsing UI
• MIDI clock generation and
synchronization

MidiDuino
• Just open up a sketch, write a few lines, and
upload it to your controller
• Having this functionality in hardware is a big
plus compared to software
• Once it’s written, just plug it in, no setup
required
• Doesn’t need a computer if you use
hardware

Exploratory
Programming
• No need to setup, doesn’t feel like an
application but more like a sketch
• Try out lots of crazy ideas
• Randomization of parameters
• Sequencers
• Cool tricks

Uses
• Change the behaviour and layout of your
custom MIDI controller
• Implement custom features for your
software or synthesizer. For example:
• “Hacking” new features out of the
MachineDrum and Monomachine
• Interfacing with Ableton Live

Interfacing with the
MachineDrum
• Control the effect machines directly over
MIDI
• Use the pitch of percussion machines to
play notes: turn the MD into a polyphonic
16-track synthesizer
• Randomize sounds and explore new
variations

Hacking the
MonoMachine
• Revert to kit and revert to track
functionality
• Multi-track joystick control
• Randomize parameters

Hacking Ableton Live
• Use the Ableton Live API for remote
control surfaces to hook into the internals
of Live
• Control clips, read out clip names,
randomize parameters, etc...

Use cases
• Simple Hello World example: send out a
MIDI note
void setup() { }
void loop() { }
void handleGui() {
if (BUTTON_PRESSED(BUTTON_1))
MidiUart.sendNoteOn(random(100),
random(100));
}

Hello World
• Scale Pitch to match a scale, for example
minor scale
void setup() { }
void loop() { }
void handleGui() {
if (BUTTON_PRESSED(BUTTON_1))
MidiUart.sendNoteOn(scalePitch(random(60,
80), 60, minorScale),
random(100));
}

Random Notes
• Same concept, but this time produce pitch
information for the drum machine
• Indicate which sound engine is loaded in a
track, then use lookup tables to produce
the correct pitch
• In this example, use the FM snare drum

Random Notes
• Lookup table for the snare drum pitch:
static const uint8_t efm_sd_tuning[] = {
1, 5, 9, 14, 18, 22, 27, 31, 35, 39, 44, 48,
52, 56, 61, 65, 69, 73, 78, 82,
86, 91, 95, 99, 103, 108, 112, 116, 120, 125,
};

Random Notes
• Tell MidiDuino which sound engine is
loaded on which track
void setup() {
LCD.line1("MD NOTE TEST");
MD::trackModels[0] = EFM_SD_MODEL;
MD::trackModels[1] = EFM_SD_MODEL;
MD::trackModels[2] = EFM_SD_MODEL;
MD::trackModels[3] = EFM_SD_MODEL;
}

Random Notes
• Send a random minorscale note when a
button is pressed:
void handleGui() {
uint8_t i;
for (i = 0; i < 4; i++) {
if (BUTTON_PRESSED(i + 4))
MD::sendNoteOn(i,
scalePitch(random(47, 80), 47, minorScale),
100);
}
}

Euclidean Rhythms
• Paper by Gotfried Toussaint: the euclidean
algorithm can be used to generate most
african and western rhythms
• Pattern of length n, using a rhythmic unit,
for example 16th notes
• Number of pulses k, which are distributed
over the pattern length

Euclidean Rhythm
• For example, 3 pulses in a pattern of 8
steps gives X . . X . . X .
• Pattern of 4 pulses in a pattern of 9 steps
gives X . X . X . X . .
• These rhythms sound “natural” even if they
are in a weird form, very easy way to try
out a lot of interesting rhythmic ideas

Euclidean Rhythm
• Idea: build a sequencer where each track is
generated using k, n and an offset from the
beginning
• Implementation of the algorithm very easy
• Same algorithm as drawing lines on a pixel
display

Euclidean Rhythm
• Algorithm generates a bit pattern with the
hits
uint32_t pattern = 0;
uint8_t cnt = len;
for (uint8_t i = 0; i < len; i++) {
pattern

Euclidean Rhythm
• Hidden away in a classed called
EuclideanDrumTrack
• Use tempo synchronization on the
MidiDuino
• Tempo can be generated internally
• Or synchronized to an external clock
source

Euclidean Rhythm
• Use a callback on every 16th note and
check for each track if a hit has to be sent
void on16Callback() {
for (uint8_t i = 0; i < 4; i++) {
if (euclids[i].track.isHit(
MidiClock.div16th_counter)) {
MD::triggerTrack(euclids[i].
pitchEncoder.getValue(), 100);
}
}
}

Euclidean Rhythm
• Amazing way to try out new interesting
polyrhythms
• Having it on hardware makes it really easy
to get into the flow
• Put away the computer, use the small
MIDI controller and try away

Euclidean Bassline
• Use the euclidean algorithm to generate
the rhythmic pattern of the bassline
• Use an arpeggiator to produce the pitches
• Length of the arpeggiator can be different
than the number of pitches, generating a
second layer of rhythmic shifting

Euclidean Bassline
• This sketch works on 3 levels
• Rhythm is produced by
EuclideanDrumTrack
• Notes are produced randomly
• Notes are transformed to MachineDrum
pitches
• Turns the machinedrum into an algorithmic
bassline step sequencer

Euclidean Bassline
• MidiClock callback produces the pitches:
void on16Callback() {
if (track.isHit(MidiClock.div16th_counter)) {
MD::sendNoteOn(ROM_TRACK,
pitches[pitches_idx], 100);
pitches_idx = (pitches_idx + 1) %
pitches_len;
}
}

Controlling graphical
ideas
• Using a MIDI controller not for music, but
to control design parameters for CNC
milling applications
• Using algorithmically generated CNC files
to mill LED lamps out of wood
• Control design parameters with the MIDI
controller instead of the mouse

Lamp sketch
• Mill circles of different radii using attractors
to create “attraction” zones

Lamp sketch
• Processing sketch generates a preview of
the milling
• Uses the RuinWesen MIDI library to
control parameters
• MidiDuino just has a simple MIDI controller
sketch sending out MIDI CC messages

Lamp sketch
• Work in progress: send the MidiDuino
information about the parameters it
controls: no MIDI information visible
anymore
•
input For = now: RWMidi.getInputDevices()[1]
.createInput(this);
void controllerChangeReceived(Controller c) {
...
}

Lamp sketch
• Find out new interesting regions by
controlling more than one parameter at
once (not easy to do with just a mouse)
• Apply MIDI algorithms and methods to
generate new combinations:
• Tempo synchronization
• Easy hookup of a MIDI controller to
control visuals in a club setting

Lamp sketch
• Lamp callback code for parameters
void controllerChangeReceived(Controller c) {
switch (c.getCC()) {
case 2:
num = c.getValue() + 1;
break;
case 3:
distance = c.getValue();
break;
}
}

Lamp sketch
• Randomize when pressing a button on the
MidiDuino, sending a Note On message
void noteOnReceived(Note n) {
if (n.getPitch() == 100) {
for (int i = 0; i < 5; i++) {
attractors[i][0] = random(0, 400);
attractors[i][1] = random(0, 400);
}
}
}

Conclusion
• MIDI hardware hacking is an incredibly
interesting thing to do
• Really changes the way you think about
music
• Hands-on approach now possible without
much setup

Workshop tomorrow
• 12 MidiDuino boards
• Let’s try it out with hardware synthesizers,
software synthesizers, Processing sketches,
and other crazy ideas

Thank you!
http://ruinwesen.com/
http://twitter.com/wesen
http://myspace.com/daswesen