Korg nanopad2 with ETC

I’ve been using a Korg nanopad with my ETC for live shows. It needed a small amount of easy setup with Korg’s free software. I mapped the MIDI to saved scenes, it allows me to jump between 64 scenes in any order.

I also discovered that the controller’s touchpad will alter the values of knobs 1 and 2. It’s an X/Y pad, x axis = knob 1, y axis = knob 2, but you can control both simultaneously. It opens up some really fun possibilities. It has me wondering about other controllers and maybe sequencers with the ETC.

Has anyone else here used a similar setup?

1 Like

Yeah! I’m sure you know this but you can also change which CC Messages the Nanopad axes control. So if you wanted to control, say the Background Color knob, set one axis to CC #25. More here:

We made the CCquencer patch for Organelle. It sends out looping CC sequences to the control the ETC knobs. Here’s a demo video of the ETCs output:

This ETC user uses an app to automate CCs with LFOs with different waveforms. The LFO is in sync with external BPM!

1 Like

All very cool @chrisk - thanks. I didn’t realize you could reassign that touchpad, but it makes sense. I also want to investigate some of the other controls on the nanopad with the ETC. I wonder what the arpegiator can be made to do with it, for example. I will dig into those links and videos, thanks!

I use a Nanocontrol with my laptop installation of ETC. I also modified midi.py and etc_setup.py so I can use any CC. I don’t have the system here, so I can’t post the changes, but I may do so this evening.

The transport-controls are next/previous, screenclear-on/off., OSD and so on.

Next steps are, that I want the modes to recognize the device on which the mode is running. So I can use the same mode on a standard ETC, a modified one, or a laptop.

what an excellent idea!

As promised my changes to the python-files to make all MIDI CC’s available:

All files are in the directory /root/ETC_Mother/.
1.) midi.py
I kept the original definition of the variable “cc” and added a new variable midi_cc. New code is marked with “###”

    # channel messages
    if ( (msg_channel == (etc.midi_ch - 1)) or (etc.midi_ch == 0)) :
        # CC original
        if (msg_type == 0xB) :
            etc.new_midi = True
            for i in range(0,16) :
                if (midi_msg[1] == 21 + i) :
                    cc = midi_msg[2]
                    if cc != cc_last[i] :
                        etc.cc_override_knob(i, float(cc) / 127)
                        cc_last[i] = cc
        # CC new version                           ###
        if (msg_type == 0xB) :                     ###
            etc.midi_new = True                    ###
            etc.midi_cc[midi_msg[1]] = midi_msg[2] ###
        # note OFF
        if (msg_type == 0x8) :

2.) etc_system.py:
All the new code marked by an “###” at the end of the line

# midi stuff (CC gets updated into knobs
midi_notes = [0] * 128
midi_notes_last = [0] * 128
midi_note_new = False
midi_cc = [0] * 128      ###
midi_cc_last = [0] * 128 ###
midi_cc_new = False      ###
ctrl = 0
midi_pgm = 0
    # check for new notes
    for i in range(0, 128):
        if self.midi_notes[i] > 0 and self.midi_notes_last[i] == 0:
            self.midi_note_new = True
    # check for new CCs                                                ###
    for i in range(0, 128):                                            ###
        if self.midi_cc[i] != self.midi_cc_last[i] :                   ###
            print ("CC" + str(i) + "; value: " + str(self.midi_cc[i])) ###
            self.midi_cc_new = True                                    ###
def clear_flags(self):
    self.new_midi = False
    self.audio_trig = False
    self.run_setup = False
    self.screengrab_flag = False
    self.midi_note_new = False
    for i in range(0, 128):
        self.midi_notes_last[i] = self.midi_notes[i]
    for i in range(0, 128):                       ###
        self.midi_cc_last[i] = self.midi_cc[i]    ###

and finally:
3.) main.py

midi_led_flashing = False
osd_is = False
midi_cc_last = [0] * 128
while 1:
    # read keyboard keys to as buttons:
    for event in pygame.event.get():
        if event.type == pygame.KEYDOWN:
            #left cursor selects previous mode
            if event.key == pygame.K_LEFT: etc.prev_mode()
            #right cursor selects previous mode
            if event.key == pygame.K_RIGHT: etc.next_mode()
            #ESC-key exits the program
            if event.key == pygame.K_ESCAPE: sys.exit()
            #the "t"-key and the period key act as trigger button
            if event.key == pygame.K_t: etc.update_trig_button(1)
            if event.key == pygame.K_PERIOD: etc.update_trig_button(1)
            #the "p"-key toggles the OSD-display
            if event.key == pygame.K_p:
                if (osd_is) :
                    osd_is = False
                else :
                    osd_is = True
            #the "r"-key reloads the mode.
            #this is helpful if you are logged in with SSH and edit 
            #the mode on the USB-stick with an editor
            if event.key == pygame.K_r: etc.reload_mode()
            #the "p"-key toggles the OSD-display
            if event.key == pygame.K_c:
                if (etc.auto_clear) : etc.auto_clear = False
                else : etc.auto_clear = True
    #Korg Nanopad sends CC's  from the buttons. 
    #next mode by FFWD-Button
    if midi_cc_last[m] == 0:
        if etc.midi_cc[m] == 127:
            midi_cc_last[m] = etc.midi_cc[m]
    if etc.midi_cc[m] == 0:
        midi_cc_last[m] = 0
    #previous mode by REW-Button
    if midi_cc_last[m] == 0:
        if etc.midi_cc[m] == 127:
            midi_cc_last[m] = etc.midi_cc[m]
    if etc.midi_cc[m] == 0:
        midi_cc_last[m] = 0
    #toggle the autoclear by the STOP button.
    if midi_cc_last[m] == 0:
        if etc.midi_cc[m] == 127:
            if (etc.auto_clear) : etc.auto_clear = False
            else : etc.auto_clear = True
            midi_cc_last[m] = etc.midi_cc[m]
    if etc.midi_cc[m] == 0:
    # check for OSC

Can I ask how are you modifying ETC? I was thinking of two hardware mods: summing stereo input for onboard converting stereo signals and gate to pedal circuit for using modular gate signals (+5V) in pedal input.

With modified ETC I meant an ETC with changed system python files. The idea is to establish a variable in the main.py which contains the branch- and version-number. So the mode would check these variables and then could be enabled to use extra features.

Regarding hardware mods: I indeed modified the pedal input to read gate signals. You have to solder a transistor with emitter-collector across the switch and feed the gatesignal over a resistor to the gate. You also simply may use an external switched-trigger to gate converter like http://www.doepfer.de/faq/gen_faq.htm#S-Trig

The other idea was to add voltage inputs which replace the voltage coming from the knob-potentiometers. But it is tricky to assure that the voltage is not too high (3.25V max) and also the pcb is not easy to modify (very fine tracks, narrow neighbourd, difficult to split, difficult to solder…).

1 Like

I’m using a workaround for this with CV-MIDI box from Kenton. Indeed, very useful feature.