Nick Robinson Loops

I use ableton live for my solo ambient projects, but my new combo Mithril are 2 vocals and myself on acoustic, so I wanted a simple, practical looper option. I had previously used a line 6 M13 (too big/limited) and an M9 (which I broke while trying to replace the micro-switches!). Finally, I persuaded myself (and my wife) that a Line 6 HX effects would fit the bill. After shopping around, I found one at £358, well below the typical street price, so I bought one.

The pedal is quite amazing and really well thought through in terms of usability. Plus, it has midi control, which I’ve used to overcome the main limitation of a one-pedal looper, that of stopping by double click. It may be my age, but when I’m recording a live loop, I find double tapping throws my timing out. Or at least, I feel it does! Since I’m getting handy at building midi projects using the arduino chip, I built myself a small pedal to plug into the HX midi in socket.

Whilst I could assign any looper controls to a pedal (except, infuriatingly, a “clear loop” command), I kept it basic, with a pedal for “stop” and another for “play”. I added LEDs (colour matched to the pedal light!) and it works faultlessly. It’s powered via USB, so needs suitable power socket handy.

I then extended the code to that switching “play” on also switched FS3 on, set to add a little dirt for solos. Pressing stop switches off both the loop and the boost.

Here’s a fritzing of the layout

and here’s the arduino code, for those in the know 😉

// midi controller for line 6 M9 to control looper - solo OD
// apr 19

#include <MIDI.h>
#include <midi_Defs.h>
#include <midi_Message.h>
#include <midi_Namespace.h>
#include <midi_Settings.h>

MIDI_CREATE_DEFAULT_INSTANCE();
// Constants
#define SWITCH1 3 // play
#define SWITCH2 2 // stop
#define SWITCHES 2    // how many switches?
# define LED1 5 // channel 1
# define LED2 4 // channel 2
int thisLed = 0;

int switches[SWITCHES] = { SWITCH1, SWITCH2 };
int switchState[SWITCHES] = { LOW, LOW };   // Initial state of switch
int leds[SWITCHES] = { LED1, LED2 };
int currentSwitch = 0;
int play = 0; // state or recording
unsigned long SwitchMillis = 0; // when button was released
unsigned long DebounceMillis = 20; //
unsigned long CurrentMillis = 0;

void setup()
{
  MIDI.begin(1);
  // Setup Switches and activation LEDs
  for ( currentSwitch = 0; currentSwitch < SWITCHES; currentSwitch++ )
  {
    pinMode( switches[currentSwitch], INPUT );          // Set pin for switch
    digitalWrite( switches[currentSwitch], HIGH );      // Turn on internal pullup
    pinMode( leds[currentSwitch], OUTPUT );
    digitalWrite( leds[currentSwitch], HIGH );
  }
  intro();
}

void loop()
{
  CurrentMillis = millis();  // get the time at the start of this loop()
  if (CurrentMillis - SwitchMillis >= DebounceMillis)  //is it time to check the switches?
  {
    SwitchMillis = millis(); //re-initilize Timer
    for ( currentSwitch = 0; currentSwitch < SWITCHES; currentSwitch++ )
    {
      if ( (digitalRead(switches[currentSwitch]) != switchState[currentSwitch] ) && (switchState[currentSwitch] == HIGH) )
      {
        switch ( currentSwitch )
        {
          case 0: //  play
            {
              MIDI.sendControlChange(61, 127, 1); // play
              delay(200); // slow down commands so the HX doesn't crash!
              MIDI.sendControlChange(51, 127, 1); // FS3
              digitalWrite( leds[0], HIGH );
              digitalWrite( leds[1], LOW );
              play = 1;
            }
            break;
          case 1:  // stop
            {
              MIDI.sendControlChange(61, 0, 1); // stop
              if (play)
              {
              delay(200); // slow down commands so the HX doesn't crash!
              MIDI.sendControlChange(51, 127, 1); // FS3
              play = 0;
              }
              digitalWrite( leds[1], HIGH );
              digitalWrite( leds[0], LOW );
            }
            break;
        }
      } // end if changed
      switchState[currentSwitch] = digitalRead( switches[currentSwitch] );
    } // go thru switches
  } // end check switches
} // end loop

void intro () // startup flashes
{
  for ( int i = 0; i < 6; i++ ) // startup flashes
  {
    for ( thisLed = 0; thisLed < SWITCHES; thisLed++ )
    {
      digitalWrite( leds[thisLed], LOW );
      delay(160);
      digitalWrite( leds[thisLed], HIGH );
    }
  }
}

This is an amazing multiFX device, based on the Helix devices, but without the amp modelling. Many players like to use their amp for “tone”, so this is an ideal and highly compact solution. featuring an unbelievable selection of classic and modern effects, with many parameters than can very easily be assigned to one of two expression pedals. It has up to 9 FX “blocks” with 6 of them switchable by footswitch. It uses a highly intuitive system with loads of “preset” pages, each of which can have 4 “snapshots, where the chosen effects for that preset are stored on or off and parameter changes are remembered. I picked mine up for £358, so shop around, some places have it at £420!

One of these blocks is a looper (you can only have 1 instance, sadly!) Whilst the loop stops dead, you can place the looper block before a reverb or delay (both with “tails”) to provide a degree of “fade out”. You have two looper options

1 Switch looper
Pretty much equivalent to the Ditto and countless other simple loopers. This takes up one footswitch on the unit.

Press the Looper switch. The LED lights red, indicating the loop is recording.
Press the Looper switch again. The LED lights green, indicating the loop is playing back.
Press the Looper switch again. The LED lights amber, indicating the loop is in overdub mode. Subsequent presses of the switch toggle between play and overdub mode.
While the Looper is in play or overdub mode, press and hold the switch for 1 second. The most recent recording is undone. Holding the switch again will redo the recording -“UNDO” or “REDO” briefly appears on the scribble strip.
Quickly double-press the Looper switch. Playback/recording stops and the LED lights white, indicating a loop is in memory.
While Looper playback/recording is stopped, press and hold the switch. The recording is deleted and the LED lights dim white. You hear a small section of the loop as it erases (needs a solution), but if you exit to (latched) preset mode, change presets then change back, the loop is cleared silently.

6 Switch looper
The same as the looper on the M9/13 series.Max. Loop Length (Full Speed) Mono 60 seconds Stereo 30 seconds. Press the Looper switch to open up 6 options

Switch 4 (bottom left) – Press to start recording a loop. Press again to overdub additional parts. Step on again to start playback in overdub mode. You can end & play the loop by pressing “play” or “play once” (which does what it says on the tin). You don’t erase loops, you just press “record” again.
Switch 5 – alternates between play & stop
Switch 6 – plays the loop once
Switch 1 (top left) – undo and redo the last overdub
Switch 2 – switching to 1/2 speed will drop the loop down one octave. Recording at 1/2 speed will double your looping memory and switching to full speed will cause the loop to play at double speed (up an octave).
Switch 3 – Step on REV/FWD to hear your loop backwards.

I find the double click to stop unhelpful in live performance, so I’ve built a simple midi pedal to provide an instant “stop” via midi. It also includes a “play” button and can be expanded to control all aspects of the looper.

Midi control (via USB or a midi in socket) is almost complete, lacking only a “clear loop” option, though I’ve suggested to them it could easily be included in a future firmware update. The CC messages required are:

CC60 0-63: Overdub; 64-127: Record
CC61 0-63: Stop; 64-127: Play
CC62 64-127 Looper Play Once switch
CC63 64-127 Looper Undo switch
CC65 0-63: Forward; 64-127: Reverse
CC66 0-63: Full; 64-127: Half
CC67 0-63: Off; 64-127: On – Looper block on/off (if available); also enters/exits Looper footswitch mode