Surfing on Entropy

March 21, 2019 at 10:28 am (art, computers, music) (, , , )

I was passed a link to this interesting comment from Brian Eno: “There is not enough Africa in computers” (thanks Richard).

I’ve now read this a couple of times and was still left wondering quite what lay behind the comment.  So I tried to find the original interview between Kevin Kelly (then editor of Wired I believe) and Brian Eno so I could read it in full.  Unfortunately it isn’t on the same link anymore, but with some googling, you can find it in the Wired archive here.

There are a number of really fascinating discussion points – I really recommend reading the whole article – and it provides the context for that isolated quote. I did find some of the answers a little contradictory at times though.

A disclaimer, to date the music and views of Brian Eno seems to have passed me by, so these comments start with this interview in isolation. I look forward to seeing what he would say now and finding more about his ideas of generative music.

On the one hand I believe he is saying he doesn’t like the “set it in motion and it will perform predictably” aspect of computers – he likes the idea of providing inspiration and guiding principles that may or may not produce something depending on the live inputs of the viewer/reader/listener – he appears to like the serendipity of it all … but later on he talks of “black boxes for music” where he has set the rules and the box produces the music according to those rules, with some input from the listener depending on their mood.  The box become some combination of player and instrument if I understand his view correctly.

Right near the start of the interview, he suggests that the orchestral tradition is too constraining, but I see it as a (more limited admittedly) set of programmable components ready to do the composer’s bidding.

When you look at how the orchestra developed from Mozart’s time through the Romantic period, contrasting those early Classical period works with Beethoven, Brahms and then the later large scale deployments of Mahler, there is quite a lot of scope for variability there and the basic “machine” evolved enormously through that time. Then when you look at what Stravinsky did in his ballet music or what Debussy did with his completely alternative view of harmony through to the likes of Messiaen recreating birdsong in his Turangalia symphony (including incorporating the electronic Ondes Martinot), then as a “programmable box” an orchestra is actually quite a versatile person/machine system in action.

I guess he doesn’t like the idea that a composer sets the rules and the orchestra is then condemned to just reproduce them.  But I wonder what he thinks about jazz and improvisation? Good jazz still follows rules, but every performance is different. But it isn’t random. Is a jazz ensemble “more Africa” than an orchestra?  Or maybe it is a matter of the illusion on unpredictability.  When I look at something like the Long Player – that is a key set of rules, and you exactly determine what the music will be at any point – but the cycle is so long (designed to last a thousand years) that every time you dip into it, you don’t really know what you will hear.  Or at the other end, is John Cage’s As Slow as Possible where you can go back after several months and the music is still exactly the same.

I guess some of this relates to the difference between analogue and digital.  Digital is obsessed with chopping up the analogue reality into small measurable chunks – be that discrete frequencies that we call semitones in Western music, pixels on a computer screen, or even the digitising of the end results as a digital bit stream to be played back via audio hardware off a CD or MP3.  But even when digital and in theory part of a finite space, that space is so vast as to approximate to the entire musical repertoire or pictorial output of any artist, composer or musician (as least as far as human senses are concerned).

I’ve always been fascinated with the idea of the computer screen representing an unimaginably large single number and that counting through them all would show every possible image that screen could display.

In theory the digitisation of music could be represented the same way – if every note on the piano keyboard had a number 1 to 88, then a piece of music (forgetting rhythm for the moment) is essentially one very long base 88 number.  That’s not too dissimilar to how a pianola worked, although physical layout of the cut-outs are key here, or even MIDI in today’s world, when linked with a sense of the flow of time of course.  I remember my school having a dictionary of musical themes and it basically worked on those lines (although it only worried about a single octave, so it was essentially a 5-10 digit “base 7” number).  I’ve always wanted that book, but so far have never seen one since.

So just because things can be reduced to number and handled by computer, is that any less “Africa” than a free-flowing analogue equivalent?  I guess a key distinction is not necessarily digital vs analogue, but more pre-determined vs unpredictable.

In a weird way, fast forward these last 20 years and computers have become so complex as to be largely unpredictable to many.  Now that these already complex machines are hooked up to the even more complex global machine that is “the Internet” (by whichever definition to choose to use – remember it is just a series of tubes), then most of us would be hard pushed to be convinced by the argument that computers are things that always behave the same way based on the same inputs.

I am reminded here of Bjarne Stroustrup when he said (I believe): “I have always wished for my computer to be as easy to use as my telephone; my wish has come true because I can no longer figure out how to use my telephone.”

I’m also reminded of the fact that computers may soon be able to pass the Turing Test, not because they’ve become as smart as humans, but possible because there is a real possibility that humans are becoming as dumb as computers…

Back to Brian Eno:

“What people are going to be selling more of in the future is not pieces of music, but systems by which people can customize listening experiences for themselves.  Change some of the parameters and see what you get.”

He was after unfinished pieces of musical ideas to be combined in a new form as the listener experiments.  Of course, in a sense he was overestimating the listeners – today listeners want “customized listening experiences” but at the granularity of the song, the tune, not the musical extract or idea or concept.  And they don’t really want the effort of having to produce it themselves.  Of course they have it in droves with on-demand streaming where algorithms are “changing the parameters” on your behalf.

His ideas for evolutionary music and art may still come about, but again probably more by presaging the idea of algorithms creating music and art. But does that make the algorithms the composers and painters?  The jury is still out on that one, but he may well get his “furniture music” this way – his “ubiquitous 24 hours a day” music “infiltrating every waking moment of our lives”.

It is interesting his view on the use of machines.  He suggest we all need to be “surfing on entropy” – to be able to ride the wave of unpredictability and complexity becoming apparent.  I think that is very, very apt today, but the huge irony here being that this unpredictability and complexity has come about by the very components he considered too constrained, “not enough Africa”, now being let loose as they’ve grown more powerful and complex, on the world.

Machines are no longer doing “predictable, boring and repetitive things” – they are the very instruments of uncertainty.  We can still exert influence – by surfing the wave of complexity:

“When you surf, there is a powerful complicated system, but you’re riding on it, you’re going somewhere on it, and you can make some choices about it.”  You either ride it an use it with skill to get your own direction, or you give up and go with the flow.

There is an interesting section discussing the difference between art and science.  Art “doesn’t make a difference” – in that he means that whilst art will stimulate emotions, create large emotional experiences (e.g. watching a film) then end when the experience ends.  Of course, with today’s blended and mixed reality, is that still the case?

A fascinating read, especially with the benefit of 20 years passing in the mean time. The context might be slightly different, but many of the thoughts are still amazingly apt for today.  I’d love to know what he thinks about these thoughts again today.




Permalink Leave a Comment

ATtiny85 MIDI to CV

March 2, 2019 at 4:07 pm (computers, music) (, , , )

There are a number of projects out there that provide a MIDI to CV function utilising some flavour of the ATtiny family of microcontrollers.  But most of them go from USB MIDI to CV but I wanted a genuine 5-pin DIN MIDI to CV.  This was the result.

It has taken a basic MIDI in circuit from the Internet (Google will find a few of these kicking around) and pairs it with the ATtiny85 CV out section of Jan Ostman’s cheap USB MIDI 2 CV design.

Update: Jan Ostman has now written a tutorial on how to do this directly using the USI on the ATtiny85. Read it directly from the expert here

The result is as follows (excuse the poor representation in Fritzing, it served its purpose). Note that the 6N138 only had 5 active pins in the Fritzing part, so the extra dodgy link shown below is a fudged link for pin 7 to GND via a 4.7k resistor.


I also have a version for the ATtiny2313, but the main changes are as you’d expect.  Basically I was having problems with the ATtiny85 missing MIDI messages and wondered if a hardware UART would be better.  Turned out it was just my dodgy code with no real error checking getting out of sync with the MIDI stream.  But it took trying it on a 2313 to highlight the real issue, so back to the ATtiny85 and now all is well.

Design wise, its fairly simple ATtiny85 wise with the pin usage as follows:

  • SoftwareSerial receive on D3 (PB3) which is physical pin 2.
  • Gate output on D2 (PB2) which is physical pin 7.
  • CV output using the PWM signal tied to OC1A triggered off timer 1, which is D1 (PB1) on physical pin 6.

The code uses the same trick that Jan Ostman used in his code – if the top compare value for PWM operation is 239 then there are 240 graduations for PWM.  To cover a MIDI range of C2 (note 36) to C7 (note 96) is 60, so the PWM compare value required for a linear CV voltage output is basically (note-36)*4.

In terms of timer control registers, this all translates over to (refer to the ATtiny85 data sheet):

  • Set PWM1A i.e. PWM based on OCR1A
  • Set COM1A1 i.e. Clear OC1A (PB1) output line
  • Set CS10 i.e. Prescaler = PCK/CK i.e. run at Clock speed
  • Clear PWM1B is not enabled (GTCCR = 0)

The value for the PWM cycle is set in OCR1C to 239, and the compare value is set in OCR1A between 0 and 239, thus representing a range of 0 to 5v giving 1v per octave, assuming a 5v power supply.

When porting to the ATtiny2313, a similar scheme was used, but timer 1 is a 16 bit timer, and the control registers were slightly different, but I still used the 0-239 range.

Reading around the different modes, I ended opting for the use of Fast PWM with the compare value in OCR1A and the maximum PWM cycle value (239) in ICR1.  The timer register settings were thus as follows:

Timer 1 Control Register A (TCCR1A):

  • 7 COM1A1 = 1 COM1A1(1); COM1A0(0) = Clear OC1A on compare match; set at TOP
  • 6 COM1A0 = 0
  • 5 COM1B1 = 0
  • 4 COM1B0 = 0
  • 3 Resv = 0
  • 2 Resv = 0
  • 1 WGM11 = 1 WGM11(1); WGM10(0) = PWM from OCR1A based on TOP=ICR1
  • 0 WGM10 = 0

Timer 1 Control register B (TCCR1B):

  • 7 ICNC1 = 0
  • 6 ICES1 = 0
  • 5 Resv = 0
  • 4 WGM13 = 1 WGM13(1); WGM12(1) = PWM from OCR1A based on TOP=ICR1
  • 3 WGM12 = 1
  • 2 CS12 = 0 CS12(0); CS11(0); CS10(1) = Prescaler = PCK/CK i.e. run at Clock speed
  • 1 CS11 = 0
  • 0 CS10 = 1

Timer 1 Control Register C left all zeros.

I don’t know if it was the version of the ATtinyCore I was using, but the bit and register definitions for Timer1 for the ATtiny2313 didn’t seem to match the datasheet, so I just used the bit codes directly.

In terms of ATtiny2313 pin definitions, the following were used:

  • Hardware serial receive on D0 (PD0) which is physical pin 2.
  • Gate output on D11 (PB2) which is physical pin 14.
  • CV output using the PWM signal tied to OC1A triggered off timer 1, which is D12 (PB3) on physical pin 15.

A quick note on the MIDI serial handling.  My first code was very lazy and basically said:

  IF (serial data received) THEN
    read MIDI command value
    IF (MIDI note on received) THEN
      read MIDI note value
      read MIDI velocity value
      set CV out value based on MIDI note value
      set Gate signal HIGH
    ELSE IF (MIDI note off received) THEN
      read MIDI note value
      read MIDI velocity value
      set CV out value based on MIDI note value
      set Gate signal LOW
      ignore and go round again waiting for serial data
END Loop

This generated a very quirky set of issues.  Basically when there was serial data available and a MIDI note on or off command detected, the read of the note and velocity data was returning and error (-1) which I never bothered checking.  Basically the code was running too fast and the next MIDI byte hadn’t registered yet.  So when (-1) was passed on as the MIDI note, it was resulting in a note on code thinking the MIDI note was 255, which was rounded up to the highest note (96).

The result was that I could see the gate pulsing in response to MIDI note on and off messages, but the CV voltage went high as soon as the first MIDI message was received.

The next version used test that said

IF (at least three bytes of serial data received) THEN

which means that if things get out of sync, eventually bytes are skipped until there are three bytes that equate to a note on/off message.  Crude, but it worked enough to show the principle.

The final code includes proper handling of the “Running Status” of MIDI, as described here:

I used the 8MHz internal clock for the ATtiny85.

To test all of it together, I used my ATtiny85 MIDI Tester.

I might add some kind of selection for the MIDI channel.  Right now its hard-coded in a #define.  One option might be using an analogue input and a multi-position switch with a resistor network.  Or maybe a “tap to increase the channel” digital input switch.  Or if I use the 2313 version, I could use more pins and use a BCD or hex rotary switch or DIP switches.

2019-03-02 16.00.27

Here is the full code for the ATtiny85 version, which can be loaded up from the Arduino environment using the ATtiny85 core by Spence Konde. 

// MIDI to CV using ATTiny85
// NB: Use Sparkfun USB ATTiny85 Programmer
//     Set Arduino env to USBTinyISP
//     Set to 8MHz Internal Clock (required for MIDI baud)
#include <SoftwareSerial.h>

#define MIDIRX 3  // 3=PB3/D3 in Arduino terms = Pin 2 for ATTiny85
#define MIDITX 4  // 4=PB4/D4 in Arduino terms = Pin 3 for ATTiny85
#define MIDICH 2
#define MIDILONOTE 36
#define MIDIHINOTE 96

// Output:
//  PB2 (Ardiuno) = Pin 7 = Gate Output
//  PB1 (Arduino) = Pin 6 = Pitch CV Output
// PB5 set as digital output
// PB1 used as PWM output for Timer 1 compare OC1A
#define GATE    2  // PB2 (Pin 7) Gate
#define PITCHCV 1  // PB1 (Pin 6) Pitch CV

SoftwareSerial midiSerial(MIDIRX, MIDITX);

void setup() {
  // put your setup code here, to run once:
  midiSerial.begin (31250); // MIDI Baud rate

  pinMode (GATE, OUTPUT);
  pinMode (PITCHCV, OUTPUT);

  // Use Timer 1 for PWM output based on Compare Register A
  // However, set max compare value to 239 in Compare Register C
  // This means that output continually swings between 0 and 239
  // MIDI note ranges accepted are as follows:
  //    Lowest note = 36 (C2)
  //    Highest note = 96 (C7)
  // So there are 60 notes that can be received, thus making each
  // PWM compare value 240/60 i.e. steps of 4.
  // So, for each note received, PWM Compare value = (note-36)*4.
  // Timer 1 Control Register:
  //   PWM1A = PWM based on OCR1A
  //   COM1A1 = Clear OC1A (PB1) output line
  //   CS10 = Prescaler = PCK/CK i.e. run at Clock speed
  //   PWM1B is not enabled (GTCCR = 0)
  TCCR1 = _BV(PWM1A)|_BV(COM1A1)|_BV(CS10);
  GTCCR = 0;
  OCR1C = 239;
  OCR1A = 0; // Initial Pitch CV = 0 (equivalent to note C2)
  digitalWrite(GATE,LOW); // Initial Gate = low

void setTimerPWM (uint16_t value) {
  OCR1A = value;

void loop() {
  if (midiSerial.available()) {
    // pass any data off to the MIDI handler a byte at a time
    doMIDI (;

uint8_t MIDIRunningStatus=0;
uint8_t MIDINote=0;
uint8_t MIDILevel=0;
void doMIDI (uint8_t midibyte) {
  // MIDI supports the idea of Running Status.
  // If the command is the same as the previous one, 
  // then the status (command) byte doesn't need to be sent again.
  // The basis for handling this can be found here:
  // copied below:
  //   Buffer is cleared (ie, set to 0) at power up.
  //   Buffer stores the status when a Voice Category Status (ie, 0x80 to 0xEF) is received.
  //   Buffer is cleared when a System Common Category Status (ie, 0xF0 to 0xF7) is received.
  //   Nothing is done to the buffer when a RealTime Category message is received.
  //   Any data bytes are ignored when the buffer is 0.

  if ((midibyte >= 0x80) && (midibyte <= 0xEF)) {
    // MIDI Voice category message
    // Start handling the RunningStatus
    if ((midibyte & 0x0F) == (MIDICH-1)) {
      // Store, but remove channel information now we know its for us
      MIDIRunningStatus = midibyte & 0xF0;
      MIDINote = 0;
      MIDILevel = 0;
    } else {
      // Not on our channel, so ignore
  else if ((midibyte >= 0xF0) && (midibyte <= 0xF7)) {
    // MIDI System Common Category message
    // Reset RunningStatus
    MIDIRunningStatus = 0;
  else if ((midibyte >= 0xF8) && (midibyte <= 0xFF)) {
    // System real-time message
    // Ignore these and no effect on the RunningStatus
  } else {
    // MIDI Data
    if (MIDIRunningStatus == 0) {
      // No record of state, so not something we can
      // process right now, so ignore until we've picked
      // up a command to process
    // Note: Channel handling has already been performed
    //       (and removed) above, so only need consider
    //       ourselves with the basic commands here.
    if (MIDIRunningStatus == 0x80) {
      // First find the note
      if (MIDINote == 0) {
        MIDINote = midibyte;
      } else {
        // If we already have a note, assume its the level
        MIDILevel = midibyte;

        // Now we have a note/velocity pair, act on it
        midiNoteOff (MIDINote, MIDILevel);
        MIDINote = 0;
        MIDILevel = 0;
    } else if (MIDIRunningStatus == 0x90) {
      if (MIDINote == 0) {
        MIDINote = midibyte;
      } else {
        // If we already have a note, assume its the level
        MIDILevel = midibyte;
        // Now we have a note/velocity pair, act on it
        if (MIDILevel == 0) {
          midiNoteOff (MIDINote, MIDILevel);
        } else {
          midiNoteOn (MIDINote, MIDILevel);
        MIDINote = 0;
        MIDILevel = 0;
    } else {
      // MIDI command we don't process

void midiNoteOn (byte midi_note, byte midi_level) {
  // check note in the correct range of 36 (C2) to 90 (C7)
  if (midi_note < MIDILONOTE) midi_note = MIDILONOTE;
  if (midi_note > MIDIHINOTE) midi_note = MIDIHINOTE;

  // Scale to range 0 to 239, with 1 note = 4 steps
  midi_note = midi_note - MIDILONOTE;

  // Set the voltage of the Pitch CV and Enable the Gate
  digitalWrite (GATE, HIGH);

void midiNoteOff (byte midi_note, byte midi_level) {
  // check note in the correct range of 36 (C2) to 90 (C7)
  if (midi_note < MIDILONOTE) midi_note = MIDILONOTE;
  if (midi_note > MIDIHINOTE) midi_note = MIDIHINOTE;

  // Scale to range 0 to 239, with 1 note = 4 steps
  midi_note = midi_note - MIDILONOTE;

  // Set the voltage of the Pitch CV and Enable the Gate
  digitalWrite (GATE, LOW);


Permalink Leave a Comment