A while ago, I wrote a tutorial on how to get the NBC/NXC running on Linux in order to program an Mindstorm NXT brick. In the tutorial, I posted an example script that turns the robot into a dancer and plays some music. The only problem is that the music was just set of random frequencies and thus was unbearable to listen to. So I though, is there a way to make it less random without the need to make it play the same thing over and over again?

Experimenting with this idea lead me to write the libmidi library. MIDI files are a collection of notes, so it seemed as the best format to use. It allowed me to just generate random notes and tell the MIDI player to play them in some order. The library also includes an example called randommusic, but just does the same thing as the dancing robot. It just plays 128 random notes. This is what it sounds like:

I am no expert on music theory, but from what I understand most songs contain only notes in one scale. And the idea also works the other way, playing notes in a scale can result in a song. The song won’t be a masterpiece, but it will be bearable. Since I am too lazy to pre-program every possible scale, I decided that I will only limit notes to ones found in an existing song instead of a scale.

After analyzing Piano Sonata No.1, that I grabbed from Kunst der Fuge some time ago, I get the following result:

It sounds much better than before, but it still sounds like it is all over the place. To fix this, I applied one more change to how the next note is picked by looking at one more piece of information when analyzing the song; the note that was played previously. That is if note B never follows note A in the existing song, then it should never do so in the random music. Here is the result:

That was a big improvement! I think that is where I will stop working on this. But more tweaks could be done in the future:

• Add random rhythm
• Analyze multiple songs

Of course, the code still needs to be ported to NXT to make a much more improved dancer robot.

The script that I wrote to do this can be downloaded here and is released under the GPL3 license. To use it, you need to have libmidi and ROOT installed. This is how it works:

1. Analyze the song

   ./analyze input.mid output.root

2. Generate a random tune.
   • The first argument is the track of the orignal song to analyze, and should be set as track1, track2 and so on. Also you can set it to song, which uses all tracks.
   • The second argument is the ROOT file with the analyzed song created in step 1
   • The third argument is the output MIDI where the result will be saved
   • The fourth argument is optional. Specifying it will ignore any previous note conditional probability.

   ./generate track input.root output.mid [unconditional]

I spent the last few days of my winter vacation experimenting with generating random music. This was inspired by my simple NXT Dancer robot, which currently just plays random tones. The idea behind this latest experiment is that (1) I build a probability density function of played notes from well known music and (2) I use that PDF to pick the notes to be played next, based on the previous note. I will post more details about this in a few days. But the important part is that I used MIDI files, which contain commands like “play this note” and “use this volume” to recreate the actual music.

Being lazy, I decided not to search a lot (I trie a bit) for a pre-made library for reading MIDI files and instead I decided to create my own. The result is libmidi, a very simple MIDI reading and writing library. To parse a MIDI file, just do this:

MIDI::File file("/path/to/file.mid");
file.open();

Then the contents of that file are available as they were found in the MIDI file. For example, to get a track and print out all of the events (the commands that tell the MIDI synchronizer what to do), do this:

MIDI::Track* track=file.track(0);
for(int j=0;j<track->numEvents();j++)
{
   MIDI::Event* event=track->event(j);
   event->debug();
}

Also libmidi contains a basic write support. You can add new events to the end of a track and call the MIDI::File::write() function to save the file that the track represents. See the randommusic example, included in the libmidi-0.1 package, on how to do this.

The downside to using the libmidi library right now is that it is not well developed yet. For example, there are only a few functions to modify the MIDI file (ei: tracks can only be appended to the end of the track) and not all meta event types have a nice define yet. Of course, I plan to fix this in the future.

But for now, you can download version 0.1 or checkout the latest development code at GitHUB. The API documentation is available here.

For more information about MIDI files, check out these websites:

• http://253.ccarh.org/handout/smf/
• http://www.piclist.com/tecHREF/io/serial/midi/midifile.html
• http://www.sonicspot.com/guide/midifiles.html