NoisyLittleBugger

Read it and weep. I know I am 😛

EDIT (2025): My code is long deprecated and has been greatly improved by Sergio Castro:

#!c++

std::string bjorklund(int beats, int steps)
{
    //We can only have as many beats as we have steps (0 <= beats <= steps)
    if (beats > steps)
        beats = steps;

    //Each iteration is a process of pairing strings X and Y and the remainder from the pairings
    //X will hold the "dominant" pair (the pair that there are more of)
    std::string x = "1";
    int x_amount = beats;

    std::string y = "0";
    int y_amount = steps - beats;

    do
    {
        //Placeholder variables
        int x_temp = x_amount;
        int y_temp = y_amount;
        std::string y_copy = y;

        //Check which is the dominant pair 
        if (x_temp >= y_temp)
        {
            //Set the new number of pairs for X and Y
            x_amount = y_temp;
            y_amount = x_temp - y_temp;

            //The previous dominant pair becomes the new non dominant pair
            y = x;
        }
        else
        {
            x_amount = x_temp;
            y_amount = y_temp - x_temp;
        }

        //Create the new dominant pair by combining the previous pairs
        x = x + y_copy;
    } while (x_amount > 1 && y_amount > 1);//iterate as long as the non dominant pair can be paired (if there is 1 Y left, all we can do is pair it with however many Xs are left, so we're done)

    //By this point, we have strings X and Y formed through a series of pairings of the initial strings "1" and "0"
    //X is the final dominant pair and Y is the second to last dominant pair
    std::string rhythm;
    for (int i = 1; i <= x_amount; i++)
        rhythm += x;
    for (int i = 1; i <= y_amount; i++)
        rhythm += y;
    return rhythm;
}

This was the most challenging piece of code to date. Outwardly simple, and with many existing examples in other languages, not to mention the C code example in Bjorklund’s paper, it should have been a doddle to implement on the Arduino, right?

But no. I realised the big downside to using the AVRISP: no access to the serial interface, which makes debugging impossible. Thankfully I could use the Teensy 3.1 to test my Code. But this in itself brought heartache, as there were some library conflicts with Teensyarduino. A troubling story to be sure, but In brief, I battled through ’til dawn and eventually cracked the bastard.

My overriding concern was – how much of the ATmega’s CPU time would be taken-up by using recursive function? I would have expected this to be a resource hog, and I worried that it wouldn’t handle 8 tracks simultaneously, slowing everything down. I’m happy with the current state of the MIDI clock (99.98% accurate), and this was something I didn’t want to compromise. I also witnessed some talk on the forums about Arduino’s limited stack size.

In the end, performance wildly exceeded my expectations. See the example outputs below.

Note that I have reversed the order or the patterns in alignment with the examples in Toussaint’s paper. See chapter 4 for many more examples. An interesting read for sure.

In the end, the pattern directions don’t matter, because I’ve implemented track rotation and track reverse in the main application. So…

For 8 steps and 3 pulses, the pattern is:
10010010

Bjorklund took 8.00 microseconds.

Cuban tresillo / Habanera rhythm. “It can often be heard in early rock-and-roll hits in the left-hand patterns of the piano, or played on the string bass or saxophone. A good example is the bass rhythm in Elvis Presley’s Hound Dog.“

The tresillo pattern is also found widely in West African traditional music. For example, it is played on the atoke bell in the Sohu, an Ewe dance from Ghana. The tresillo can also be recognized as the first bar of the ubiquitous two-bar clave Son given by [x . . x . . x . . . x . x . . .].

For 8 steps and 5 pulses, the pattern is:
01101101

Bjorklund took 10.00 microseconds.

Cuban cinquillo. Used extensively in jazz, 50’s rockabilly and West African traditional music. e.g hand-clapping pattern ‘Hound Dog’.

For 12 steps and 4 pulses, the pattern is:
100100100100

Bjorklund took 10.00 microseconds.

The 12/8-time Fandango clapping pattern. (I know, I know)

For 3 steps and 2 pulses, the pattern is:
011

Bjorklund took 5.00 microseconds.

E(2,3) = [x . x] is a common Afro-Cuban drum pattern. For example, it is the conga rhythm of the (6/8)-time Swing Tumbao. It is also common in Latin American music, as for example in the Cueca.

Lastly, a silly example to check performance again:

For 83 steps and 56 pulses, the pattern is:
01110110110110110110110110110110110110110111011011011011011011011011011011011011011

Bjorklund took 63.00 microseconds.

This is going to be damn sweet.
🙂

I’m usually the one to grumble when I come across all those meaningless, grubby 20-second videos on Youtube. But today I’m adding my own. What the hell.

Here is Bjorklund just come to life:

At this moment I have a tight MIDI clock running on the ATMega328 at 24ppqn, with the option to go to a higher resolution if and when I trade-up to a better processor(Teensy 3.1 here I come!).

The 4 encoders and buttons are multiplexed using a single MCP2317, and the LED matrices are driven by 2 MAX7219s (both apparently counterfeit but working perfectly).

What you see are the available tempo divisions from slowest (each quarter note) to fastest (each MIDI tick) flashing across the screen.

I’ve come-up with an elegant way to deal with the note queues, rotation and sending MIDI. I can send notes on 8 tracks, remaining stable to master BPM of >300.  All Looking good so far!

All that’s left to do is implement Bjorklund’s algorithm and feed it’s output to the note queue.

Then finally the controls/menu system and that’s it! It’s all optimization from there. It seems the most challenging part is documenting the process, but I’m gathering my notes…

🙂

I should be wiring-up the 4x4pole, but here I am fiddling with breadboards. Suddenly got it into my head that I must build an Euclidean Rhythm based MIDI/CV sequencer. Bjorklund’s algorithm will be used:

The problem reduces to the following: construct a binary sequence of n bits with k one’ s, such that the k one’ s are distributed as evenly as possible among the zero’ s. If k divides evenly (without remainder) into n, then the solution is obvious. For example, if n = 16 and k = 4, the solution is [1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0]. The problem of primary interest is when k and n are relatively prime numbers [23], i.e., when k and n are evenly divisible only by 1.

Toussaint discovered (only in 2004!) that the resulting patterns of spaced pulses often represent the rhythms of many word music styles. This presents a simple way to generate new and interesting drum patterns.

There are already other Euclidean generators out there, and even one in the MIDIbix Seq4, but I have my own nascent ideas, even if I only a little knowledge on how to implement them. Another distraction! 🙂

The logical conclusion to this effort should be a PCB for a unit that can act as a standalone MIDI/CV sequencer in a box, and one that is small enough to be integrated into a Eurorack setup. After some research I decided to start with Arduino. It comes with MDI libraries as standard, and already there are lots of interesting projects out there to reference.

In keeping with the DIY philosophy, I forewent the purchase of an Arduino board and instead opted to set-up a development environment using ATmega microcontroller and the Arduino libraries: – essentially to create an Arduino clone on a breadboard.

I am using the ‘standard’ Arduino chip – the ATmega328p (used in the MIDpal). As I had a spare ATmega644 (used in the Shruthi-1), I decided to breadboard it as well. The 644 is not officially supported by Arduino, however there is an Arduino-compatible bootloader called Sanguino.

There is plenty of information out there on how to breadboard these chips. The most useful video I found was this one from Notes and Volts, which helped me setup the 328p in no time.

In the process, the concept and function of the pins became clear, and I could easily map the ATmega pins to their Arduino equivalents using the following diagram:

For the 644 I used this reference and this pinout diagram:

Once hooked-up, I needed a way to program the chips. Fortuitously I had an Atmel AVRISPmkii to hand. I bought this to program my Shruthi chips and used it for all of 5 minutes a few years ago.

There are some issues to watch out for when using the AVRIPSMKii with Arduino:

• The various sources I referenced all used a 10K pull-up resistor on the reset pin, however for the AVRISPMkii to work properly, this pull-up resistor must not have a value higher that 4.7KOhm. See P26 of this document.
• In Win7, the Atmel USB driver conflicts with the Arduino IDE. A different driver must be installed. Full details here.
• On Linux, the toolchain and associated libraries need to be installed. Further, to get the Arduino IDE working, the correct USB device permissions must be set specifically for the AVRISPMKii. This is achieved by updatinbg the UDEV rules. See P12 of this document. Note: I had to use ATTR{idProduct} instead of SYSFS{idProduct}.
• If using avrdude we must always specify that we are using the the port (-P usb). See the tutorial here.
• A green status LED on AVR indicates that connections are good. With the AVRISP, the board MUST be separately powered (5v) in order for the AVR to detect and program the chip.

OK, so after overcoming the AVRISP driver issues, the next task was to set the fuses and install the Arduino boatloader onto the virgin chips. This requires hooking-up the AVRISP to the correct Arduino/Sanguino Pins. Referencing the pinout diagrams above, making the connections is an easy task, but one that must be approached slowly.

Referencing the AVRISPmkii pinouts:

Just to be clear, this is pin 1:

I made a little breadboard adaptor for it…

Ending-up with something like this:

After triple-checking the connections, I fired-up Arduino IDE. After many failed attempts, I was still not able to bootload the damn things. Attempts at querying with avrdude always returned the following error:

avrdude: Device signature = 0x000000
avrdude: Yikes! Invalid device signature.
Double check connections and try again, or use -F to override
this check.

A web trawl suggested that this was due to the crystal not oscillating. Switching-out the crystal and trying instead a 16Mhz resonator returned the same error.

As it turned out, the default avrdude transfer speed is too fast for the virgin chips, therefore it’s necessary to adjust the baudrate (-B option in avrdude) to allow the initial communication. I didn’t realise this until after I solved it, and this was the problem that soaked-up most of my troubleshooting time. Bah!

The desperate answer in my case was to install Atmel AVR studio 6.2 – an overly torturous and bloated product (1.5Gb install), but one that bore immediate results when following this blog post.

Later, I realised that I could have done this much more quickly with Linux, and without the need for that massive Atmel install. Here are the required commands (Ubuntu).

Now fire-up Arduino IDE. No serial port is recognized on the AVRISPMKii, therefore trying to upload a sketch will return a ‘no Com port‘ error. It took me a few minutes to figure-out that you must instead ‘Upload using Programmer’ i.e press shift when sending the sketch (or just  cntrl-Shift-U). Also, it’s important to ensure you are uploading to the correct board type in the Arduino IDE (Arduino UNO vs Sanguin 644).

I attached a MIDI out port and an LCD, loaded-up a simple MIDI sketch to test it.

It worked first time. A great start!

Next steps will be to wire-up some pots and buttons, and start writing the code.