Minimalist Lo‑Fi Minimalism

By Kevin on April 1, 2025

Whilst I'm not an ardent fan of Philip Glass, (more like an amateur enthusiast), there are certain pieces of his that I do really quite like. The violin concerto goes without saying - some parts of that are wonderful. And I quite like the Low Symphony based on the music of David Bowie.

But the piece I like the most, but really have to be in the right mind for, is his opera Einstein on the Beach. The last time I saw through the whole thing was when it was live-streamed by Elbphilharmonie back in 2023 with the narrative poems read by Suzanne Vega. It was quite something.

But when you think about it, minimalist music actually ought to go quite well with microcontrollers, so this is a short experiment into programmatic minimalism by attempt to capture the essence of one of the movements of Einstein on the Beach - the Knee Play 1.

Warning! I strongly recommend using old or second hand equipment for your experiments. I am not responsible for any damage to expensive instruments!

If you are new to Arduino, see the Getting Started pages.

Parts list

Pi Day MIDI Sequencer
MIDI Synth Module configured as follows:
- Channel 1 - organ
- Channel 2 - lower voices
- Channel 3 - higher voices

The Circuit

I've used the circuit from my Pi Day MIDI Sequencer which is a I2C connected 4-digit seven segment display and a MIDI interface.

The Code

The seven segment display code was well covered in my previous projects so I won't repeat that here now.

The code supports four tracks of music as follows:

Ostinato, sustained bass in the organ part.
Two voice parts. These would ordinarily sing the numbers but I'm just having them "ooh" and "aah".
A numbers part. This will actually display the numbers to match the notes being "sung".

There is an array the top of the sketch with the main detail for a single full pass through the three bars of the main phrase. The three bars have 4, 6, and 8 beats in them and this pattern repeats in various different ways throughout the movement.

Musically there are three passes through this phrase with the bass only. Then there are two instances where the voices join in. From that point onwards the score shows a missing note at the start of one of the bars for the voices - different missing notes create variations of the music.

This is where I've gone more programmatic with the code in that I'm not encoding the entire score as written, but instead have a random number generator which picks a random number between 0 and 3 and depending on the result will skip the first beat of bar 1, 2 or 3, or if the result was 0 then it will play all bars fully. One of the benefits of my approach of course is that the music could go on indefinitely.

As the music has a steady pulse to it, I've encoded the 18 beats as a step sequencer with 36 steps. This allows me to have some silence between each sung note. The sequencer works as follows:

For voices, store a MIDI note number; 0 for a rest; or -1 to continue the previous note.
For numbers, store the number; 0 for blank (0 is not used in the music); or -1 to continue the previous state.
For the bass/organ - same as for the voices.

Here is the entire sequence for all four parts.

#define STEPS 36
uint8_t bass[STEPS] = {
45,-1,-1,-1,-1,-1,-1,-1,43,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,36,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
};
uint8_t ten[STEPS] = {
57,0,57,0,57,0,57,0,55,0,55,0,55,0,55,0,55,0,55,0,48,0,48,0,48,0,48,0,48,0,48,0,48,0,48,0
};
uint8_t sop[STEPS] = {
60,0,60,0,60,0,60,0,62,0,62,0,62,0,62,0,62,0,62,0,64,0,64,0,64,0,64,0,64,0,64,0,64,0,64,0
};
uint8_t num[STEPS] = {
1,-1,2,-1,3,-1,4,-1,1,-1,2,-1,3,-1,4,-1,5,-1,6,-1,1,-1,2,-1,3,-1,4,-1,5,-1,6,-1,7,-1,8,-1
};

I have to keep track of the current bass or voice note playing per channel so I can send an appropriate MIDI NoteOff message when required.

The general logic for playing a step for the bass or voice parts is as follows:

void doBass (int i) {
  if (bass[i] == 0) {
    // Rest
    if (lastbass != 0) {
      MIDI.sendNoteOff(lastbass, 0, MIDI_CHANNEL_BASS);
    }
    lastbass = 0;
  } else if (bass[i] < 128) {
    // New note
    if (lastbass != 0) {
      MIDI.sendNoteOff(lastbass, 0, MIDI_CHANNEL_BASS);
    }
    MIDI.sendNoteOn(bass[i], 64, MIDI_CHANNEL_BASS);
    lastbass = bass[i];
  } else {
    // do nothing
  }
}

This is the logic for playing one step of the bass part. It is repeated for the voices too.

Sequence wise, I have several routines that decide which parts of the piece is being performed. There are three main sections:

Introduction - three times through the bass phrase only.
Two full passes of bass and voices (and numbers).
Introduce the randomness to start skipping the first beat of certain bars.

And then I essentially repeat the last step ad infinitum.

Find it on GitHub here.

Closing Thoughts

My initial thought was to use three Arduino tones to perform the piece, then I wondered about just building a "MIDI to numbers" device and adding it to my Lo-Fi Orchestra.

Finally, I settled on using MIDI generated from the Arduino as part of its scheduling of the numbers to display. I think that was the right choice and is a nice balance of useful timbres, suitably minimalist programming, and something vaguely reminiscent of the original.

Kevin