Beam Beats tangible rhythm sequencer: work is in progress!

Beam Beats is an interactive and tangible rhythm sequencer that translates the geometry of beacons on the ground into rhythms and polyrhythms thanks to a rotating laser beam. This experimental MIDI instrument is about investigating self-similarities in polyrhythms, as described in this post.

Update: Here’s the video of a demo at Dorkbot at La Gaité Lyrique in Paris

BeamBeats demo at Dorkbot at la Gaité Lyrique from cyrille martraire on Vimeo.

Before I report more on this project with demos and videos, here are some pictures to illustrate the work currently in progress, thanks to lasercutting techniques in particular:

The brand new laser-cut acrylic structure
The prototype laser head and retro-reflection light sensor
The Arduino to detect the light variations and convert them into MIDI notes
Very early design of beacons each with their own light sensor

This prototype works, here’s a picture of the laser beam rotating:

The revolving laser beam reflected on the wall

And here’s a very short early video (no sound)

Beam Beats – revolving laser beam to detect beacons from cyrille martraire on Vimeo.

I’ve been working on the Arduino source code to add the ability to send MIDI clock in order to sync Beam Beats to other MIDI devices.

Now I mostly need to conclude on the design for the active  beacons(sensors stands) and the passive (retroreflective adhesive stands) beacons, and find out what to play with this sequencer…

Every post on this project:

Read More

Jam Session “Dancing Queen” on May 15

We did it again! On May 15 we had our third jam session at home on a Sunday afternoon.


As usual, total improvisation: switch the machines on, start the recording, then everyone plays whatever he/she likes!

Nothing was prepared in any way, except the sounds loaded in the MPC. We had no lyrics prepared, next time it could be a good idea to prepare something…


Rongrong, Yuan, Muzhou, Pierrick, Yunshan and Cyrille performed this session. 6 hours recorded in total, aggressively cut to keep the most “interesting” bits:

Jam Session “Dancing Queen” May 15 by cyriux

Everyone more or less played on everything, with most lead vocals by Rongrong. We unfortunately did not record any flute solo from Pierrick (next time you need to perform in front of a mike!).

For the curious

The setup was organised as a ring with an MPC 500 for the beats, a microKorg for the leads, a KaossPad for effects and as a looper for the mic or the mixer subgroup, all midi-clock sync-ed, plus an old Casio keyboard with nice cheesy sounds. Enjoy!

Read More

Jam Session at home

On a Sunday afternoon, fifteen friends, all non musicians but two amateur musicians, joined the machines set in turn, around 8 at a time, to improvise electro or hip-hop rhythmic grooves. Of course there were food and drinks as well.

The goal was to introduce music making in an attractive way: no pressure, no constraint, no reason to be shy, just have fun!

Don’t be shy

Some arrived saying “no no no I will never sing in the mike”, but ended up doing the mike to record voice loops into the Kaoss Pad… Other spent time to figure out how to play something musical from machines they were touching for the first time. It was amazing how everybody got into it!

Here is a time lapse overview, unfortunately silent:

Jam Session at home with friends from cyrille martraire on Vimeo.

The machines setup

The machine set was primarily composed of an Akai MPC500 with various programs (drums, stabs, acapella chops, etc.), a Korg Kaoss Pad 3 with an Shure SM58 mike and a Korg microKorg, all MIDI clock-ed together, and all mixed into a Yamaha MG12/4 with a Boss SE-70 reverb send. There were also a 49-keys Casio keyboard and a Yamaha SHS10 mini handheld keyboard, both used as MIDI controllers to drive an EMU Turbo Phatt. Various circuit-bent toys were also pre-mixed and then fed into the Kaoss Pad as well, to get the best out of them.

Every machine has its own appeal: the Kaoss Pad 3 is the most appealing at first, but then it gets more difficult to master. The microKorg, thanks to its sync-ed arpeggiator and its modulation wheel is also rewarding very quickly. The MPC is somehow harder since you must be rather accurate when playing for the rhythm to sound good. The EMU Phatt is very easily rewarding, especially when using the Beats programs or other programs made of several sounds laid over the keyboard.

Fun or accurate: this is the question

One note about loops, either on the Kaoss Pad or in the MPC: if they help to improve the accuracy of the music (repeats perfectly each time), they also kill a lot of fun out of it since you only have to play once, record, and then you are done! On the other end, playing repeatedly the same thing (or at least trying to) helps to get warmer and warmer!

Thanks all for joining us for this party, and see you for next time!

Thanks Lai for the beautiful b&w picture!

Read More

(Arduino) Interactive Generative Sequencer

Following my ongoing work on a theory of rhythms and a corresponding physical instrument using lasers, here is a version of the same idea implemented into an Arduino: a generative sequencer. The idea is to generate rhythms, and perhaps melodies, from one rhythm seed, then use mutated copies of it to create something more interesting, all this in realtime using knobs and buttons.

This is not ‘yet another step sequencer’, but really a generative music device, that builds a real time MIDI loop based on an underlying theory described in a previous post.

This is work in progress, and is shown ‘as is’ for the sake of getting feedback.


The approach is to generate a “seed” of rhythm that is then copied a few times into “instances”, each instance being distorted in its own way. The controls for the human player (or programmer) are therefore all about adjusting the deformations (transforms actually) to apply to each instance, and of course defining the seed.

Eventually each instance is wired to a MIDI note, channel etc. to remote control a synthesizer or a drum machine or any MIDI setup, to generate actual sounds.

Principle: one seed, many transformed instances
Principle: one seed, many transformed instances

The maths

Given a seed of rhythm of lengh length composed of pulses, each of duration m, then:

for each instance k of the seed, each pulse i,
pulse(k, i) happen at time t = phase(k)  + i . m . stretch(k), t < length
where phase(k) and stretch(k) are the phase and stretch settings for the instance k.

Realtime control of the sequencer is therefore all about setting the phase and stretch values for each instance, once the pulse number and the pulse duration of the seed have been globally set.

Inversely, for a given instance k, at time t, we have a pulse if:

there exists an i, such as t = phase(k) + i * m * stretch(k)
i.e. i = (t - phase(k))/(m * stretch(k))

In other words, if

(t - phase(k))/(m * stretch(k)) is integer
(i.e. numerator % denominator == 0)

Thinking in MIDI ticks (24 per quarters), in 4/4, for 1 bar, length = 4 * 24, phase is in [-24 .. 24] and stretch is in [4:1 .. 1:4] and m in [12 .. 48] by steps of 12 ticks.

The implementation is the very simple: for each instance of the seed, and given its phase and stretch settings, whenever the modulo condition above is true, then we emit its MIDI note, with the set velocity on the set MIDI channel.

As usual, the pace of the loop is primarily based on the value from the Tempo potentiometer.

Overview of the circuit
Overview of the circuit, with the switches and the knobs

Adding some swing

8th note swing
8th note swing

The EMU SP-1200, early Linn machines, Roland 909, Akai MPC and many other machines are famous for their swing quantize, a feature that delays every other note by a certain amount in order to create a groovy feeling (see Swung Note).

Different machines express the swing factor in different ways, we will stick to the MPC format, expressed in percent from 50% (no swing, play straight) to 75% (hard shuffle).

For a swing for 8th notes, this swing factor represents the ratio of the period of the first 8th note over the period of the second 8th note, in percent.

In the Arduino code of our generative sequencer, we chose to do a fixed swing for 8th notes only.

A big constraint is that we are limited to a resolution of 24 ticks per quarter note, which is not a lot! By contrast, MPC have a 96 ppq resolution. Because a hard swing of 70% translates into hardly 2 MIDI ticks at 24 ppq, doing the swing on top of the ticks will not be accurate at all!

The only solution is to vary the internal tempo before and after each 8th note. The drawback (or advantage) is that the MIDI clock being sent will also move, reflecting the same swing. Since the Swing knob value is actually between 0 and 25 (to be read from50% to 75%), the tempo before (t-) and the tempo after (t+), are given by:

t+/- = (50 +/- swing) * t / 50
where t is the base loop period without swing

Video Demo

Here is a video demo. There are only 3 instances, selected by the switches 1, 2 and 3; the first switch selects the GLOBAL settings: step duration (quarter, 8th etc.), swing factor, tempo. Each instance can be set its Phase, Stretch, MIDI note, velocity and MIDI channel. Here I have preset the MIDI channels, instance 1 on channel 1 (the microKorg) and instances 2 and 3 on channel 2 (the MPC with a drum kit).

The goal is to build a simple beat by only adjusting the parameters.

(Arduino) Interactice Generative Sequencer from cyrille martraire on Vimeo.

The code

You can download the Arduino project here: generativesequencer1; below is the same source code for convenience. The code includes the knob pagination described in a previous post.

Please note that some parts of the code are not used any more, such as the big constant arrays, and some comments are not up to date (e-g no prime number anymore).

All analog inputs are wired to simple knobs. Digital inputs 8, 9, 10 , 11 are the four buttons used to switch pages. Digital output 12 is the activity LED (showing when the knob is active within the knob pagination). MIDI out is on the Tx pin.

 * Generative rhythm sequencer, more details at:
 * Knob mapping according to a grid 2^n . prime^m, against the MIDI 24 ticks/quarter.
 * Knob pagination to multiplex the knobs several times with LED to show activity.
 * Memory-less event handling thanks to maths relationships.
 * MIDI note on output on every 16 channel and MIDI clock according to tempo.
 * Creative Commons License Cyrille Martraire
int debug = false;
//---------- USER INPUT AND PAGINATION -----------
#define PAGE_NB 4
#define KNOB_NB 6
#define PROTECTED -1
#define ACTIVE 1
#define SYNC_LED 12
// the permanent storage of every value for every page, used by the actual music code
int pageValues[PAGE_NB][KNOB_NB];
// last read knob values
int knobsValues[KNOB_NB];
// knobs state (protected, enable...)
int knobsStates[KNOB_NB];
// current (temp) value just read
int value = 0;
// the current page id of values being edited
int currentPage = 0;
// signals the page change
boolean pageChange = false;
//temp variable to detect when the knob's value matches the stored value
boolean inSync = false;
// ---------- KNOBS CALIBRATION AND MAPPING ---------
// rhythmic scale, to select globally
int scale2[] =  {1, 2, 3, 6, 6, 12, 12, 24, 24, 48, 48, 96, 192, 384, 768};
int scale3[] =  {1, 2, 3, 6, 9, 12, 18, 24, 36, 48, 72, 96, 144, 384, 768};
int scale5[] =  {1, 2, 3, 6, 12, 15, 24, 24, 30, 48, 60, 96, 120, 384, 768};
int scale7[] =  {1, 2, 3, 6, 12, 21, 24, 24, 42, 48, 84, 96, 168, 384, 768};
int scale9[] =  {1, 2, 3, 6, 12, 12, 24, 24, 27, 48, 54, 96, 108, 384, 768};
int scale11[] = {1, 2, 3, 6, 12, 12, 24, 24, 33, 48, 66, 96, 132, 384, 768};
//int scale13[] = {1, 2, 3, 6, 12, 24, 12, 24, 39, 48, 78, 96, 156, 384, 768};
int maxValue = 890;
int scaleLen = 15;
int *scale = scale3;
int step = 60;
int center = 30;
int coeff = 10;
//---------- GENERATIVE MUSIC CODE ---------
unsigned int cursor = 0;
int bars = 1;
int length = bars * 4 * 24;
int PHASE = 0;
int STRETCH = 1;
//int DIRECTION = 2;
int NOTE = 2;
int DURATION = 3;
int VELOCITY = 4;
int CHANNEL = 5;
// GLOBAL KNOBS (seed and global settings)
int seedDuration = 24;
int seedTimes = 8;
int instanceNb = 4;
int swing = 0;//0..25% (on top of 50%)
int loopPeriod = 125/6;//120BPM
int actualPeriod = loopPeriod;
//instance i
int phase = 0;
int stretch = 1;
int note = 48;
int duration = 24;
int velocity = 100;
int channel = 1;
void setup(){
   Serial.begin(19200); //debug
  } else {

  pinMode(13, OUTPUT);


void setupKnobMapping(){
  step = maxValue / scaleLen;
  if (step * scaleLen < maxValue) {
  center = step / 2; // for phase only
  coeff = step / 8; // +/-3 ticks, for phase only

void loop () {

    //TODO partition inputs reading every other cycle if required by CPU load


    // parameters for each instance (pages 1 to 3)
    for(int index = 1; index < instanceNb; index++){

    cursor = cursor % length;
void poolGlobalSettings(){
    // global parameters
    seedDuration = mapC(pageValues[0][0], maxValue, 1, 4) * 12;
    seedTimes = mapC(pageValues[0][1], maxValue, 1, 16);
    instanceNb = 4;//mapC(pageValues[0][2], maxValue, 1, PAGE_NB);
    // = mapC(pageValues[0][3], maxValue, 1, PAGE_NB);
    swing = mapC(pageValues[0][4], maxValue, 0, 25);
    loopPeriod = mapC(pageValues[0][5], maxValue, 63, 2);// 12.5 ms - 62.5
    if (cursor % 24 <= 12){
      actualPeriod = (50 + swing) * loopPeriod / 50;
    } else {
      actualPeriod = (50 - swing) * loopPeriod / 50;
    //TODO prime number selection and scale switch
// custom map function, with min value always 0, and out max cannot be exceeded
long mapC(long x, long in_max, long out_min, long out_max)
  if (x > in_max) {
    return out_max;
  return x * (out_max - out_min) / in_max + out_min;
void processSeeInstance(int * params){
  phase = mapC(params[PHASE], maxValue, 0, 24);
  stretch = mapC(params[STRETCH], maxValue, 0, 4);
  stretch = pow(2, stretch);// 4:1 to 1:4, in fourth
  note = mapC(params[NOTE], maxValue, 36, 48);
  //duration = mapC(params[DURATION], maxValue, 6, 96);
  velocity = mapC(params[VELOCITY], maxValue, 0, 127);
  channel = mapC(params[CHANNEL], maxValue, 0, 4);

  if(isPulse(phase, stretch)) {
     noteOn(channel, note, velocity);
// for each instance, and for the given cursor, is there a pulse?
boolean isPulse(byte phase, byte stretch){
  int num = cursor - phase;
  int denum = seedDuration * stretch / 4;
  return num % denum == 0;
// Sends a MIDI tick (expected to be 24 ticks per quarter)
void midiClock(){
  Serial.print(0xF8, BYTE);
//  plays a MIDI note for one MIDI channel.  Does not check that
// channel is less than 15, or that data values are less than 127:
void noteOn(char channel, char noteNb, char velo) {
   midiOut(0x90 | channel, noteNb, velo);
//  plays a MIDI message Status, Data1, Data2, no check
void midiOut(char cmd, char data1, char data2) {
   Serial.print(cmd, BYTE);
   Serial.print(data1, BYTE);
   Serial.print(data2, BYTE);
void setupPagination(){
  pinMode(SYNC_LED, OUTPUT);
  for(int i=0; i < KNOB_NB; i++){
    knobsValues[i] = analogRead(i);
    knobsStates[i] = ACTIVE;
// read knobs and digital switches and handle pagination
void poolInputWithPagination(){
  // read page selection buttons
     value = digitalRead(i);
     if(value == LOW){
         pageChange = true;
         currentPage = i - FIRST_PAGE_BUTTON;
  // if page has changed then protect knobs (unfrequent)
    pageChange = false;
    digitalWrite(SYNC_LED, LOW);
    for(int i=0; i < KNOB_NB; i++){
      knobsStates[i] = PROTECTED;
  // read knobs values, show sync with the LED, enable knob when it matches the stored value
  for(int i = 0;i < KNOB_NB; i++){
     value = analogRead(i);
     inSync = abs(value - pageValues[currentPage][i]) < 20;

     // enable knob when it matches the stored value
        knobsStates[i] = ACTIVE;

     // if knob is moving, show if it's active or not
     if(abs(value - knobsValues[i]) > 5){
          // if knob is active, blink LED
          if(knobsStates[i] == ACTIVE){
            digitalWrite(SYNC_LED, HIGH);
          } else {
            digitalWrite(SYNC_LED, LOW);
     knobsValues[i] = value;

     // if enabled then miror the real time knob value
     if(knobsStates[i] == ACTIVE){
        pageValues[currentPage][i] = value;
void printAll(){
     Serial.print("page ");

     //printArray(knobsValues, 6);
     //printArray(knobsStates, 6);

     for(int i = 0; i < 4; i++){
       printArray(pageValues[i], 6);
void printArray(int *array, int len){
  for(int i = 0;i< len;i++){
       Serial.print(" ");

Read More

My First Circuit Bending

Last week-end I have bought five noise-making plastic toys at a yard sale in Paris; I then ordered knobs and switches from ebay and from a local electronic store. What for? For the purpose of circuit bending of course!

Noisy toys found in a yard sale
Noisy toys found in a yard sale

First failure

Out of the four toys, one was already non working when trying with new batteries. Once opened, there was nothing visibly wrong, every wire connected. Whatever what we do with it, only noise comes out from the two speakers.

The mini keyboard, already broken before any circuit bending
The mini keyboard, already broken before any circuit bending

Second failure

I searched how to start the art of circuit bending (I have been taught electronics in the academic fashion in engineering school, but I suspected circuit bending was somewhat different: usually in a lab, you do your best to avoid short circuits, at all costs!

The toy I killed by mistake
The toy I killed by mistake

I therefore read (but too quickly) the introduction by Reed Ghazala before opening the second toy. Then I started to short circuit each pin to each other while triggering the noises. After a few minutes, I believed I had found an interesting connection (as the sound was getting slightly strange) but immediately after, no more noise. I killed the toy.

Now I understand that having the sound slightly strange is precisely what we need to avoid. It was written in the guide…

Third try

Looking further I discovered additional advices (use only the body resistance to start connecting pins together, use a voltmeter to mark every high tension on the circuit to avoid them later).

The little music box, before anything happened
The little music box, before anything happened

Then it was quick since the circuit is so simple. I added a mini Jack output and checked it with headphones. I also added a switch on the output in order to interrupt the sound, and another (UPDATE) on the batteries wires to be able to shut down very quickly, just in case…

The inside with additional switches and Jack output
The inside with additional switches and Jack output

With only 4 resistors on the circuit it was easy to bypass them with my body resistance, and R2 is obviously controlling the pitch. So happy, this is really that simple. R2 is 100K?, so now I must test bypassing it with a potentiometer to find out the right value range to use. As it is all SMC (surface mount component) there will be some sport.

UPDATE I removed the 100K? SMC resistor that controls the pitch and replaced it with a 470K? potentiometer plus a serial 10k? resistor plus a serial switch to pause the playback (playback goes on where it was when switching back on, since the pause switch actually stops the clock to the chip).

The most difficult part was actually to put everything into the small box, without breaking anything.

It is a very simple circuit bending since only the pitch is controlled here.

Here is a demo video on Vimeo:

Scratching with a circuit bent jukebox toy from cyrille martraire on Vimeo.

Read More

Making music the macro way

At the beginning, there was the tape

Back to the 80’s technologies

Of course, with some musical education, I believed, just like many other people in the trade, that this was not really music, just cheating: you did not have to care with any music theory, it could not be correct

Then the hit from MARRS: “Pump up the volume” came and after some debate everybody had to agree sampling other people audio (not just music, but also TV speech, radio commercials etc.) was there for long, and it was music. Hip-hop, initially based around playing records to get the beat, quickly adopted samplers as its core instrument, sampling past records extensively.


In clubs or within a hip-hop group, Dj’s had developed special skills to manipulate records playing on their turntables, and this set of techniques (including the famous scratching, and many other tricks) was named turntablism.

By analogy to turntablism, someone has coined the term loopism to describe this new way of making music by combining loops in realtime. Here is an example below, with a loop played live from the pads of an Akai MPC and recorded “on the fly” in a looper pedal. Once the loop is playing on and on, the Dj performs good old scratches on the turntables on top of it:

Going software

Preshish Moments: a combination of a custom MIDI controller and custom MaxMSP patches creates a custom overall instrument based on loops, with enough control to fully compose and remix live, with no interruption, for hours.

Wii Loop Machine 2.0 :: an intro from The Amazing Rolo on Vimeo.

A live, and wiimote-controlled loop machine: Wii Loop Machine by The Amazing Rolo.

As we have seen, a DAW such as Ableton Live or Reason can be seen at the same time as a studio in a box or as a new kind of musical instrument. The old saying of “playing the studio” (producers meant by that that the studio must be easy and intuitive enough so that one can create in a spontaneous fashion in it) has become litteraly true.

At the same time, the need for ready-made loops has created a huge new market. Loopmasters, PrimeLoops, Modernbeats and many other have jumped to that market. With every kid now willing to be the next Dre or Timberland, it is a good business for sure…

Not only for beginners

If anyone can create convincing music using the built-in loops of a DAW, professional producers can as well, and they do it! Logic Audio (Garage Band bigger brother) built-in loops have been used to create the biggest part of the massive hip-hop hit Love in this Club, by Usher.

The tutorial website mjtutoriels explains (in french, but this is easy to follow without understanding the words) how to do a remake of the instrumental track:

Read More

Music Production Patterns

Here is a collection of tips and tricks to produce current popular genres (Hip-Hop, House and Electro in particular) found freely on the Internet, and presented into the pattern form.

The pattern form

This means each trick or set of related tricks is given an expressive name along with a short description of its intent. Full description of each pattern is left out, as it would represent a rewriting of many sources (I have no time for that), but links to the full source material are given at the bottom in the references section.

Of course this is only useful if you already know what it is about, and should be considered more as a reminder.

Arranging a tune

At the top level of a tune structure, we deal with the arrangement.

  1. Anticipation and Surprise: create anticipation and surprise: Build-ups (Snare Rolls, Reverse Crash, Filter Opening, Synth Fx, Accelerating LFO, Pitch Glide), Breakdowns (drop parts, close filter)
  2. Playing The Studio: allow for spontaneous action in the studio, e-g. Dub-Style (mixer, reverb send, effect send, use of feedback)
  3. Round Trip Creation (e-g. beat first, lyrics, then back to beat to optimize with the vocals)
  4. Question-Answer: Q/A relationship to sustain a tension: Q (lyrics) – A (riff); see also Da Capo, Ternary Form
  5. Useful and insightful definitions:
    1. Vibe: inspiration for a tune, the focus throughout the song (vocal, sound, chord progression…); can be found before or after a beat is created
    2. Character: anything that is highly distinctive (sounds, voice, filter effects, fills, sweeps…)
    3. Energy: drums, bass, and riffs (arp, synth, guitar…) driving the tune

A typical project studio
A typical project studio

Make It Believable

Sometime we want to achieve realism, sometime we do not want to, but there is always a need to be realistic in some way, even in a virtual musical world.

  1. Layer, Layer, Layer: no simple sound, layer similar sounds to make them richer and more complex
  2. Ambiance: Preserve or re-create ambiance (Overhead miking, Parallel Compression…)
  3. Altered Background: sounds in the back should have some reverb and high frequencies attenuated
  4. Possible for a Performer: the performer could possibly do that (or not if we want artificial feeling)
  5. Tone Matching (compatible sounds, physically or for the genre)

Groove and Feel

Getting a strong groove is key to a good tune.

  1. First Beat Straight and Loudest
  2. Primary Beats Louder (than secondary beats)
  3. Swing: play offbeats late, from straight to triplet feel
  4. Silence Matters: make sure there is silence between hits (use Gating, Side Chain Compressor, Manual Edit in the DAW, Adjust Decay)
  5. Dragging or Rushing: make other beats late or early
  6. Evolving Dynamics (through velocity, modulation, filter or sample start modulation)
  7. Layer Beats: Backbeat, Polyrhythm, Ghost Notes
  8. Sync to Tempo: Sync everything (arpeggiator, effects, lfos) to tempo or to some multiple of the tempo (via MIDI or manually)
  9. Notes Duration Matter: the funky bass, it’s in the notes duration

Sound Design

For more character, a tune needs unique and special sounds

  1. Happy Accident: make sure happy accident can still happen, and Record Everything
  2. Unlimited Combinations: Combine Everything to Everything (Compressor, Filter, Effects, Automation, Instruments…)
  3. Extreme Processing: Pitch Shift, Reverse, Audible Looping, Glitch, Overdrive
  4. Uncommon Devices: Circuit Bending, Domestic things that make sounds, exotic spaces to record in
  5. Hybridate Audio Features: (Extract-Promote): extract sample part then loop it as the oscillator in a synth, extract convolution profile then apply it to another sound, extract FFT spectrum or RMS envelope to apply it to another sound etc.
Using a musical toy for special sounds
Using a musical toy for special sounds

Keep it Simple (The Enough Repetition Rule)

  1. Four Hooks Maximum: do not confuse the listener with too many distinct things
  2. Reuse With Variation: it is OK to use again and again the same hook provided it is slightly changed to make it less obvious and boring
  3. Attractive or Complementary: some tracks must attract attention, other tracks must not compete for attention
  4. KISS: Keep it simple (but no simpler): stick to simple melodies, riffs and chords progressions

Keep It Interesting (The Enough Variation Rule)

  1. Alternate Sounds (Alternate Claps, Samples switched by velocity etc.)
  2. Modulations (Sample Start Modulation, Automation of whatever)
  3. Effects, Triggered Effects (via automation)
  4. Widen Stereo: Hard Pan, Haas Effect (Hard Pan With 15-60ms Delay), Stereo Modulation Effect (Chorus etc.)

A ProTools Session during mixing
A ProTools Session during mixing


We’ll fix that in the mix.

  1. The Drum and Bass Backbone: Get them right and solid first
    1. Exclusive Frequencies: boost one, cut the other by the same amount on the same frequency
    2. Exclusive Timing: if possible, if one plays, the other should be silent; variations involve using Side Chain Compressor or Gating
  2. Tune Drums: tune low-end drums and percussion sounds to the root tonic note to avoid very low frequency beats
  3. Sound Substitution: if it cannot sound good, change the sounds
  4. Frequency Separation: reduce clutter with sounds frequencies not overlapping too much
  5. The usual traps: Phase & Mono (phase issues result in Comb filter effects or phase cancellation; clubs are more or less mono)
  6. Create Space (aka Multidimensional Mix): Left, Right, Foreground and Background: Stereo Placement, Damp Highs, Delay + Pan
  7. Less is More, know when to cut something
  8. Mixing Order Priorities: e-g. for Hip-Hop: D&B first, Vocals, then other tracks
  9. Mixing Panning Priorities: most important tracks centered, the rest panned around
  10. Sub Mixes: drums, leads & vocals, the rest, or drums, bass, the rest
  11. Mix down several mixes: Main Mix, Raised Vocals Mix (lead and back vocals +1dB), Lowered Vocals Mix, TV Live Mix (no lead vocals), Instrumental Mix (for promotion)
  12. Mixing for the genre and the goal: More extreme for clubs, more “tone-down” for radio…

Other Techniques

  1. Side Chain Compressor: consider using a separate track to trigger the side chain for more control
  2. Automate level on basses that play too many notes with a different level
  3. Widening stereo for drums: add background kick with reverb and less highs, add stereo claps
  4. Tips to enhance background vocal:
    1. Add Silk: hipass filter >900Hz
    2. Add Sheen: boost 11-12KHz 1-4dB
    3. Heavier effects than lead vocals: subtle ping pong stereo delays, hall reverb, plate reverb, and choruses
    4. Multiple Takes: double, triple, stacking harmonies: For example, pan low vocal/harmony tracks hard left & right. Next, pan medium vocal/harmony tracks 75% left & 75% right. Lastly, pan high vocal/harmony tracks 40% left & 40% right.
  5. Compressor: (too many resources on that one…, typical gain reduction: 10-15dB)
  6. EQ: (too many resources as well), Cut or Boost?


Read More

Geometric Rhythm Machine

In the post Playing with laser beams to create very simple rhythms” I explained a theoretical approach that I want to materialize into an instrument. The idea is to create complex rhythms by combining several times the same rhythmic patterns, but each time with some variation compared to the original pattern.

Several possible variations (or transforms, since a variation is generated by applying a transform to the original pattern) were proposed, starting from an hypothetical rhythmic pattern “x.x.xx..”. Three linear transforms: Reverse (”..xx.x.x”), Roll (”x.x.xx..”) and Scale 2:1 (”x…x…x.x…..”) or 1:2 (”xxx.”), and some non-linear transforms: Truncate (”xx..”) etc.

Geometry + Light = Tangible transforms

The very idea behind the various experiments made using laser light beams and LDR sensors is to build an instrument that proposes all the previous transforms in a tangible fashion: when you move physical object, you also change the rhythm accordingly.

Let’s consider a very narrow light beam turning just like the hands of a clock. Let’s suppose that our clock has no number written around, but we can position marks (mirrors) wherever on the clock surface. Still in the context of creating rhythms, now assume that every time a hand crosses a mark (mirror) we trigger a sound. So far we have a rhythmic clock, which is a funny instrument already. But we can do better…

Going back to our rhythmic pattern “x.x.xx..”, we can represent it with 4 mirrors that we position on a same circle. On the illustration below this original pattern is displayed in orange, each mirror shown by an X letter.. If we now link these 4 mirrors together with some adhesive tape, we have built a physical object that represents a rhythmic pattern. The rotating red line represents the laser beam turning like the clock hands.

Illustration of how the geometry of the rhythmic clock physically represents the transforms
Illustration of how the geometry of the rhythmic clock physically represents the transforms

Now we have a physical pattern (the original one), we can of course create copies of it (need more mirrors and more adhesive tape). We can then position the copies elsewhere on the clock. The point is that where you put a copy defines the transform that applies to it compared with the original pattern:

  • If we just shift a pattern left or right while remaining on the same circle, then we are actually doing the Roll transform (change the phase of the pattern) (example in blue on the picture)
  • If we reverse the adhesive tape with its mirrors glued on, then of course we also apply the Reverse transform to the pattern (example in grey on the picture)
  • If we move the pattern to another (concentric) circle, then we are actually applying the Scale transform, where the scaling coefficient is the fraction of the radius of the circle over the radius of the circle of the original pattern (example in green on the picture)

Therefore, simple polar geometry is enough to provide a complete set of physical operations that fully mimic the desired operations on rhythmic pattern. And since this geometry is in deep relationship with how the rhythm is being made, the musician can understand what’s happening and how to place the mirrors to get any the desired result. The system is controllable.

To apply the Truncate transform (that is not a linear transform) we can just stick a piece of black paper to hide the mirror(s) we want to mute.

If we layer the clock we just described, with one layer for each timbre to play, then again changing the timbre (yet another non-linear transform) can then be done by physically moving the pattern (mirrors on adhesive tape) across the layers.

From theory to practice

Second prototype, with big accuracy issues
Second prototype, with big accuracy issues

Though appealing in principle, this geometric approach is hard to implement into a physical installation, mostly because accuracy issues:

  1. The rotating mirror must rotate perfectly, with no axis deviation; any angular deviation is multiplied by two and then leads to important position deviation in the light spot in the distance: delta = distance . tan(2 deviation angle)
  2. Each laser module is already not very accurate: the light beam is not always perfectly aligned with the body. To fix that would require careful tilt and pan adjustment on the laser module support
  3. Positioning the retroreflectors in a way that is accurate and easy to add, move or remove at the same time is not that easy; furthermore, even if in theory the retroreflectors reflect all the incoming light back to where it comes from, in practice maximum reflectance happens when the light hits the reflector orthogonally, which is useful to prevent missed hits

Don’t hesitate to check these pages for progress, and any feedback much appreciated.

Read More

Rhythmic clock machine

The rotating mirror and the 4 laser beams
The rotating mirror and the 4 laser beams

I finally received ten retroreflectors, the experiments started in Playing with laser beams to create very simple rhythms”, we can now move on.

Once again, the rotating mirror is reflecting the four parallel laser beams so that they sweep a 180 degrees area, where some retroreflectors are positioned to hit the beams trajectories.

Every time a beam hits a reflector then it should trigger a sound on a MIDI synth (here it is my little microkorg playing the sounds).

Generative music (a.k.a mangled rhythm)

However in the first try I forgot to set a short loop perid (the period was set to 100ms). Given the velocity of the laser beam when it hits the reflectors there is very little time to catch the signal on the sensors, and with a measure every 100ms the Arduino is missing most hits.

This means we got a simple and regular theoretical rhythm that is mangled by the input sampling process, and this fuzzyness actually creates “interesting” generative music, as in the video:

Generative music installation with laser beams and low-frequency sensors sampling from cyrille martraire on Vimeo.

Note that it is not totally random… (actually it is not random at all, just the result of different frequencies that sometime are in sync and most times are not).

Laser beams on the wall
Laser beams on the wall

Regular rhythm at last

With a shorter Arduino loop period (10ms) it becomes reliable: every (almost) hit triggers a note, as illustrated in the next video where we can hear a steady rhythmic pattern.

The Arduino code is quite simple: for each of the 4 sensors, read analog value, compare to threshold, debounce (not to send multiple notes for the actual same hit), then send MIDI note.

Arduino code for the rhythmic clock project

Laser beams generate regular rhythm at least from cyrille martraire on Vimeo.

Any feedback welcome…

Read More

Musical instruments for musicians and non-musicians: Put into practice

Other posts in the series Musical instruments for musicians and non-musicians:

  1. Part One: Controls: Analysing how continuous or discrete controls on the sound affect playability to great extent
  2. Part Two: Constraints: How embedding musical theory as constraints makes the instrument easier and more rewarding
  3. Part Three: Exotic examples: Examples of exotic instruments and how they achieve good or not so good results
  4. Part Four: Put into practice: Let’s put theory into practice to build an easy and musically-sounding Theremin

Now we want to put that into practice to build a musical instrument. Let’s consider we want to do something inspired by the Theremin, but simpler to play and more funny to look at while easier to build as well.


Here is now a case study: We want to build an instrument that must be:

  1. Playable by friends that know very little in music: in other words really easy to play
  2. Attractive for friends that enjoy the fun of playing and jamming together: must be expressive
  3. Suitable for groovy electronic music (house, hip-hop, electro, acid-jazz, trip-hop and a bit of techno)
  4. Able to participate within a small band among other instruments, mostly electronic machines
  5. With a funky look and visually attractive when performing

Design and justification

The finished instrument
The finished instrument

Based on these requirements, and after some trials and error we go for the following:

  1. Finger physical guidance, because it is too hard to keep hands in the air at the same position (req. 1)
  2. Bright leds plus light sensor as a primary way of playing, for the funky look and visually attractive performance (req. 5)
  3. Discrete pitch as primary way of playing, with pitch quantization against a pentatonic scale, easy, good sounding (but coupled to one fixed tonality unless putting configuration buttons) (req. 1)
  4. Expression on the pitch when a note is pressed send pitch bend events to modulate the pitch as on a guitar  or real theremin; this only happen after a note is pressed, not to conflict with the primary pentatonic scale (req. 2)
  5. Allows for additional expression using a distinct light sensor mapped to a Midi Continuous Controller (controller 1: modulation wheel) (req. 2)
  6. Continuous rhythm control to start the project simply, plan to quantize it on 16th notes according to a midi clock later (tradeoff to keep simple right now, should be even simpler due to req. 1)
  7. MIDI controller rather than integrated synthesizer to allow for very good sounds generated from external professional synthesizers (req. 3)
  8. Internal scale setup within the range between C3 and C5, to dedicate the instrument to play solo on top of an electronic rhythm (req. 4)
  9. Arduino implementation (easy to implement pitch quantization logic and expression controls)


The very simple circuit
The very simple circuit
The Arduino board
The Arduino board
  • An aluminium rail (from a DIY shop) is fixed to an empty salt box as the body (hence the name “Salty Solo”)
  • A LED (from Booxt) slides on the rail
  • The main sensor and the expression sensor are two simple LDRs connected through a voltage divider to two Arduino analog inputs
  • Two buttons are simply connected to two Arduino digital inputs.
  • The MIDI out DIN plug is connected to the Arduino Tx pin.
  • The rest is in the Arduino software!

I have decorated the salt box with adhesive stuff…

Playability and fixes

At first try, playing the Salty Solo is not that easy! A few problems happen:

  1. Reaction time (or “latency”) is not good
  2. Moving the light with the left hand is not very fast, hence impedes playing a melody that sounds like one.
  3. Also there is a kind of conflict between the note quantization that does a rounding to the closest accurate note, and the expression control that allows to “bend” notes.

The first problem has been solved by increasing the Arduino loop frequency down to 100Hz (wait period = 10ms); to prevent sending MIDI continuous controller and MIDI pitch bend too often we therefore needed to send them (when needed) once out of a few loops.

For the second problem a workaround has been done by using the second button to trigger the next note in the scale, and pressing both buttons together triggers the second next note in the scale. Basically, in the (almost) pentatonic scale we use this usually means jumping to the third or to the fifth. This kind of jump is very common when playing guitar or bass guitar thanks to their multiple strings, and it does help play faster while moving the left hand much less. With two buttons like this it is much easier to play melodic fragments.

The last problem has been solved a bit randomly: because of a bug in the code, the pitch bend only happen when on the highest note: this saves the most useful case of playing the guitar hero on a very high note while bending it a lot. On the other notes, sliding the left hand descend or ascend the scale instead. Further playing and external opinions will probably help tweak this behaviour over time.

Here is the Arduino source code for Salty Solo

Here is a video to illustrate how it works…

Experimental instrument for musicians and non-musicians from cyrille martraire on Vimeo.


Other CC that could be used (however the modulation wheel can also control the same parameters, on a program by program basis on a synth):

  • 1 Modulation Wheel or Joystick (positive polarity) (MSB)  Can be effectively remapped to other controllers on some synth
  • 7 Volume (MSB)  If you re-route to Controller 7, your software mixer will mess up
  • 71 Resonance (aka  Timbre)
  • 74 Frequency Cutoff (aka  Brightness )

And the panic button: 123 All Notes Off

Read More