A new, free software release for Novation’s Launchpad could make your device a lot more usable – and it shows how useful OSC can be for hardware, even if that isn’t OSC hardware. (Now, imagine what OSC-native hardware can do.)

There are plenty of misunderstandings about OSC and the monome out there. Among them, there’s the notion that OSC won’t work without “extra software,” or that the only reason to use OSC messages with something like Novation’s Launchpad grid controller would be to emulate a monome.

Here’s the secret: even if you still don’t know what OpenSoundControl is, the idea is to make messages readable.

Novation released the MIDI message mappings for its Launchpad — that’s a good thing! (See previous post.) But because of the utilitarian and somewhat arbitrary way in which MIDI describes devices, MIDI messages just aren’t terribly readable. For instance, one button is called 50h (in hex), or 80 (in decimal). Where’s 80? Uh…. yeah, no one knows. And simple grid devices like the Launchpad and monome illustrate just how abstract MIDI is. The Launchpad has an 8×8 grid of buttons. You might expect them to be numbered from 0,0 to 7,7, or 1,1 to 8,8. But that’s not actually possible in MIDI.

Will Crossland to the rescue. He’s been working on an OSC wrapper for the Launchpad in Max/MSP (easily ported to other environments if you like). This makes the Launchpad more usable and more logical. It’s just one of what I think could be plenty of efforts to use arrays of buttons on music controllers more fluidly and flexibly. That, in turn, could take the DIY musical ingenuity shown by the monome community to the next level.

Oh, and Will even has an open MIDI networking tool, also built in Max – relevant to the earlier discussion of the day.

http://www.chippanfire.com/SoccoChico/Software

Will’s full description follows.

I thought you might be interested in an OSC wrapper I have been making for the new Launchpad.

From the off, this IS NOT simply a way to make the Launchpad act like a Monome. Oh no. This is a wrapper for converting the MIDI communication provided by Novation into a more human readable (and memorable!) OSC formatted protocol. Additionally the wrapper incorporates a banking system that provides one layer of unaltered MIDI communication (for connection and use with Ableton Live, with all the expected features in-tact) and eight layers (switchable from the Launchpads surface) of OSC transmitting (and controlled) decoupled grid action.

The wrapper is based in MaxMSP, but uses it only for selecting MIDI IO ports, udp communication to the ‘localhost’ (via netsend/netreceive to make it Pd compatible) and a single [js] object with the actual handler/wrapper inside it. Oh, and there’s a local loopback function for testing you have the write MIDI IO selected for each Launchpad you hookup… The wrapper (theoretically, not that I own a fleet) supports up to six Launchpads, each uniquely addressable. If you get really greedy, the javascript could be altered to support more; it is just a 3d array of data elements at its core, currently limited to [6] in one dimension…. The limit of six is a reflection of the maximum number of control surfaces Ableton Live supports.

Specs at a glance:

– Supports up to 6 Launchpad devices, each individually addressable via OSC/MIDI
– Retention of the default MIDI mode for use with Ableton (via internal midi bus)
– 8 OSC mode ‘user banks’ (per device) where the Launchpad (well, technically the wrapper) sends/receives OSC using a markup similar to that used by another popular ‘grid’ device [though it does not directly support Monome markup, as row/col/frame etc messages are not used)
– user bank switching from the Launchpad via top row of buttons
– retains all data received on any bank (even if the Launchpad is not currently focused on it) and updates the surface accordingly when swiching banks

As the handler magic is ALL done via a single javascript file, ANYONE can edit the functionality in their favourite text editor. You then need only MaxRuntime to run the code inside. While this is not an ‘open-source’ solution by any stretch, it can at least be tailored to an individuals needs without spending any money. As the wrapper will communicate happily with Pure Data, an avenue exists for freeware development of OSC patches that use the Launchpad as an interface (via the wrapper).

The appropriate files (along with suitably concise/detailed) documentation can be downloaded from my website (http://www.chippanfire.com/SoccoChico/Software)

Finally, the OSC protocol I have used is fully detailed in the download. It is essentially an extended version of the basic subset (i.e. /press and /led) employed by the Monome. My intention is not provide a ‘Monome Emulator’; the similarity in protocol is both a courteous nod to the Monome creators, and logical progression. The Monome OSC protocol is clearly well thought and well suited to addressing a 2D grid so why reinvent the wheel? I’d expect any sensible grid based OSC controller to use a similar markup as the original is so well thought out…

I have added extensions that allow for the multiple device/multiple bank addressing, as well as some extra ‘data’ for the extended colour set available to the LEDs. If you want to use the wrapper with Monome apps you’ll have to get your hands dirty converting between the two OSC protocols (not that that would be too difficult). The lack of support for /row, /column etc messages is just one example of why this is technically an inferior device to the Monome; that said, i’d still be making a wrapper like this for the banking/multiple device features it enables if I had the budget to buy such a beautiful device…

p.s. Where I am saying OSC, at this stage I really mean ‘OSC formatted’. The implementation is limited to using the netsend/netreceive objects in Max (which perhaps limits their reception to Max/Pd?). I’m a bit too new to using OSC to say I am ‘definitely’ sending Full Packet Messages that could be picked up by any OSC client…. I’d be happy for someone with more know-how to take the final steps in making it truly OSC compliant…

I imagine this could generate plenty of feedback, so fire away.

Compact MIDI controllers for your fingers are plentiful, but tiny foot controllers are far fewer. map~map aka Marcus Fischer decided to build his own by performing a simple but clever mod of the KORG nanoKEY. Now, personally, I find the nanoKEY the one product in the nano series that’s lacking; it feels more like a QWERTY keyboard than anything resembling a MIDI keyboard. But Marcus transforms it into the world’s most compact and portable foot controller. You may have to be somewhat delicate with your toes, but he says the solution works perfectly!

i’ve been wanting a compact usb midi foot pedal for a long time. i built one out of a usb number pad last year but it was less than ideal. tonight i popped all of the keys but five off of my korg nanokey in order to see how it would work as a pedal. it turned out that it worked really well. i cut some small pieces of plywood out to raise the key height and some scrap plexiglass to cover up the missing keys. a little spray paint and double stick tape and it was all finished.
i think it turned out pretty well. not bad for a cheap keyboard and scrap materials.

279 / nanopedal

Those wooden blocks look quite lovely. KORG, you may have inadvertently created a new product.

The Covert Seq – Creating patterns and Presets from Bjorn Vayner on Vimeo.

The Covert Operators and Bjorn Vayner have become my favorite go-to source for wild Ableton Live hacks. And even before the release of Max for Live, Bjorn has built some terrific, simple step-sequencers using Live’s Racks feature. That’s just the Racks feature – no Max patches or hidden features anywhere to be found. Sure, I suppose the clip view itself can be seen as a kind of step sequencer, but this gives you a unique way of generating sequences.

If you just want to begin playing with step sequencing in Live, Bjorn has a new download, aptly called The Covert Sequencer, as seen in the video at top. It’s free, it’s fun, it celebrates the 5th Anniversary of Covert Ops and the 10th of Ableton Live (good grief!), and it’s all voodoo built with dummy clips and MIDI effects.

Full post, downloads, and video tutorials:
The Covert Seq [The Covert Operators]

If you want to try your hand at the ninja skills behind all of this, Bjorn posted a screencast back in August revealing his secrets:

Making a Step Sequencer in Ableton Live. from Bjorn Vayner on Vimeo.

And if you like this sort of thing, definitely don’t miss The Covert Operators’ exclusive creation for CDM, making elaborate use of the racks and slicing features of Live 7 and later:

Exclusive: Free Ableton Live Slicing Pack by Covert Operators

Slice of Winter from Bjorn Vayner on Vimeo.

Take a weekend, and make something: that’s the challenge behind the Music Hack Day, which joins a growing phenomenon of events built around collective creation. (CDM held its own tangible interface hackday online, which I definitely hope to follow up soon!) Initiated by Dave Haynes of music sharing service Soundcloud, the Hack Day has already hit London. Many of the events were Web app-based and focused on consumption rather than creation of music, but we also saw a chordal synth plug-in and beer bottle percussion instrument.

The Berlin Hack Day, which wound up earlier today, offers still more projects focused on the creation side of music hacking. Having Ableton and Native Instruments as sponsors likely helped the mood. And as you’d expect from one of the world capitals of creative hacking, Berliners don’t disappoint.

Among the projects: a beautiful, elegant 3D sequencer, a fun bird-and-sky multitouch soundmaker with multitouch trackpad input, and a robotic xylophone controlled by monome. Someone even worked out a way to turn NI’s Maschine into a rhythm game, complete with Street Fighter sounds.

I’ve got some of my favorite projects here, but see also an eyewitness report (in English and Italian) at Audio News Room:
Just back from Music Hack Day Berlin
… and keep your eye on the wiki:
Berlin Hack Submissions

xylobot run by monome from robb on Vimeo.

Monomist Rob Böhnke and Ramsey Arnaoot created one of my favorite hackday projects so far: a monome-controlled robotic xylophone. The ingredients: one monome grid controller, one Java application for step sequencing to the output, one Arduino open source controller board, and one terrific xylophone “robot” made of an array of servos that strike the bars of the instrument. Oh, and some hot glue and wood, of course.

Project details

Debugging

Audio loop

Of course, what’s especially impressive is nailing this in just a weekend – imagine what they could do with more time and iterations.

Proof that musical visualizers don’t always have to be trippy, futuristic, Tron-like 3D landscapes (and that’s me speaking as a fan of such things), Gernot Poetsch instead chose a whimsical environment with clouds and cartoon birds, inspired by the graphic identity of Twitter. (No actual Twitter is involved, meaning you lose the, ahem, unreliable, buggy, unfiltered chat network but keep the cutesy happy sky! Works for me!)

The visuals are built in Quartz Composer, which via OSC transmits messages to synthesis language ChucK for noisemaking. The surprise is, the multitouch input is not a Lemur or an iPhone – it’s the new MacBook touchpad under Snow Leopard!

iLoveAcid is a beautiful-looking nodal sequencer by Jakob Penca which uses wireframe “tracks” to guide music playback through a sequencer, transmitting events to your soundmaker of choice via MIDI or OSC. By using curved timelines and connections, it’s a veritable model railroad of music, in which formations combine to form more complex structures instead of simply stepping across a grid. Despite appearances, it is so far only two-dimensional – but then, the z displacement could easily be assigned to some form of modulation. I’m really eager to see the video of this.

One ingredient: Processing, which makes it easier to write visual code and to connect to Java libraries.

Project Page

The hardware controller for Native Instruments’ Maschine software drum machine has been adapted to other software, like Ableton Live. But this is surely the first time it’s been made into a game. Using Maschine’s MIDI output as a game control and sounds from Street Fighter, MaschineFighter is a simple, Simon-style rhythm game. Unlike Simon, though, there’s a twist – instead of rote patterns generated in advance, you face off against a friend and try to out-rhythm each other, battle style. I think it’s actually a pretty brilliant idea, and could become a new sensation for us electronic music nerds – not to mention, it’ll finally test our rhythm in a way electronic performance often does not. (Correction: It is Mac-only, making use of the PYMIDI Objective-C based library, which, since everything else that starts with “Py” usually means Python – a la jThings that mean Java – I assumed, incorrectly, was built on Python. But anyway, if you like the idea, carry on! And, actually, having a pure Objective-C CoreMIDI interface is also pretty awesome.)

Hoping for a video of this, too.

If you have a project that didn’t make this list, or if you add documentation after the fact, let us know.

Making music into an object – the central genius of recording – could be a wonderful thing. But the CD was always somewhat utilitarian as a distribution mechanism, with its easily-splintered plastic jewel case and inserted artwork that paled next to the grand visions of the LP.

Moldover is the latest artist to experiment with ways of re-imagining the musical object. Already a fan of custom sonic circuitry, he made his CD into a circuit board. Some of it is just aesthetic, like the printed lettering. But there is also integrated noise-making circuitry for a very simple optical Theremin (well, at least, a light sensor-driven oscillator), plus a headphone jack. There’s actually quite a lot of function you can get out of that when plugging into a computer.

The album itself is comprised jazzy bleepy jams (in varying proportions). You do pay for this deluxe, handmade circuit goodness. The US$25 “Pocket Edition” seems to be the sweet spot, with a pocketable version of the circuit board. It still has a built-in speaker, turning the jewel case into self-sufficient sonic hardware instead of a throwaway. The $50 version comes with the full custom-printed circuit board for the track listing, but you can’t pocket it, which means you have exactly $25 and one custom Theremin less in your pocket.

Check out the music and purchases at Moldover’s site:
http://moldover.com/quicklinks/buy.html

The joy of being on YouTube is you get strange comments like this:

Who let you out? of your mom’s basement? Go back to building lego trainsets to transport your cocoa from the kitchen to your computer desk.

Hey – that’s a great idea, come to think of it.

Justifying the musical object can sometimes get ridiculous, but so long as there are genuinely creative ideas that fit the music, I think music may have a more interesting future in the post-industry world than it did before.

Updated – previous applications of this idea: I’m typing quickly before I head to lunch, and I commit the major sin of not mentioning our friend Tristan Perich’s infamous 2005 release 1-bit Music. Whereas Moldover is turning the packaging into an instrument and inserting a traditional CD, Tristan made the entire jewel box the playback mechanism – the album is embedded in the circuitry, and you listen to it directly.

An electronic circuit is assembled inside a CD case with a headphone jack on the side. The device plays back 40 minutes of low-fi 1-bit electronic music—the lowest possible digital representation of audio.

1-bit Music (Tristan also did a great workshop at Handmade Music. So if you want to play with these ideas, and you’re in the NYC area, there’s only one place you should be tomorrow night.)

We talk a lot about novelty, but my hope is people rip off both Moldover’s and Tristan’s idea here – and invent their own twist on this concept. I’d love to have a shelf full of circuit CDs, instead of dead, silent plastic!

dromama from Altitude Sickness on Vimeo.

Turning one knob and bouncing up and down may work for some, but virtuoso electronic performers want more live control out of music. Why? Because we have more fun. Raymond Weitekamp is a monome power user based at Princeton who has organized like-minded monomists. As with Edison’s performance work yesterday, Raymond is working to develop real performance technique.

He’s already got the monome doing more that button mashing, thanks to clever mapping of tilt controls. (Check out the custom housing, too.) But to provide additional timbral controls, Raymond makes use of the Korg nanoKONTROL and the humble MIDI Remote Scripts I made and documented here on CDM. The nano provides some compact, accessible controls for adjusting the active rack. Details below.

If you want to learn from this setup, Raymond is sharing everything he’s doing, so you can take this in a direction that works in your performance rig. Here’s the full setup:

Software:
-smack-a-duck: vimeo.com/4739761
-mlr_aes_mdb: princeton.edu/~rweiteka/mlr_raw_0.2.zip
-midi_bends: princeton.edu/~rweiteka/midi_bends_0.3G_RAW.zip
-midi_bends midi remote script: princeton.edu/~rweiteka/MIDI_Bends_LiveRemote.zip
-nanokontrol midi remote script: createdigitalmusic.com/media/files/korg/korgnano_live.zip
-ableton live

Discussion:
post.monome.org/comments.php?DiscussionID=5458

Samples:
Drums from the “droms” sample pack by ro: post.monome.org/comments.php?DiscussionID=5414
Beach Boys – Mama Says
Viktor Vaughn – Raedawn

Thanks:
ro, tehn, soundcyst, peter kirn

From that discussion thread (well worth checking the whole thing out), here’s the basics on how the bits fit together:

Since it may not be immediately obvious what’s going on, I’ll elaborate for the curious amongst you:

mlr_aes_mdb => soundflower => live
midi_bends => IAC midi bus + midi remote script => live
nanoKontrol => midi remote script => live
smack-a-duck => soundflower => live

I modified Peter Kirn’s midi remote script for the nanoKontrol, and wrote my own for midi_bends. The tilting of the monome on the left (Tuppernicus) is controlling the 8 encoders of whatever the active FX rack is. The knobs on the nanoKontrol control those same 8 encoders. This way, I can use either to control the same FX parameters. I like this a lot better than 1:1 midi mapping, because it allows multiple methods for controlling the same parameters. Tuppernicus also controls the FX toggles (4 FX x 6 channels), drum rack, and active channel/effect rack. The monome on the right (Tupperbot) is running my slightly tweaked (added rowfix) version of mlr_aes_mdb 0.4.

Ableton Live is just one choice, of course. I’m actually trying to get some similar tools together on the Linux side, where this sort of combination fits naturally with the JACK audio server. I hope to have something to share by mid-fall.

Ready for more dynamic control of Ableton Live, on the cheap? My how-to on MIDI Remote Scripting in Ableton Live was just last week, but it has already inspired new scripts for hardware, this time on the Novation Nocturn. (My examples for the tutorial were the Korg nanoPAD and nanoKONTROL.) The Nocturn is also very easy to slip into a backpack or carry-on, and very affordable at US$100-130 street. It just happens to become more valuable with a little user hacking.

Why the Novation Nocturn? After all, Novation touts their own Automap technology for just this purpose. But Novation assumed you only want to use the Nocturn Automap with your plug-ins and not to control Live. Here’s the non-dynamic hack from Novation:

How to control Ableton Live with the Nocturn?

Musician NCKN (”Nicken”) of Aachen, Germany has a better solution. He uses MIDI Remote Scripting to create a downloadable file that will map the Nocturn’s eight knobs to your device racks automatically. If you did pony up for Automap PRO, it’s useful, too, as it allows mapping buttons to Live keystrokes. (Bome MIDI Translator would be another option.)

Complete instructions and a free download at NCKN’s site. Be sure to check out his music, too; there’s some wonderful stuff.

DIY: Automap in Ableton Live with Novation Nocturn

Beautiful ambient-ish tracks with field recordings and acoustic noises blended elegantly into an electronic production:

Back to the controller that has an Ableton logo tattooed on it, we’ve got still more APC40 hacking going on, too. Darren Cowley sends along his Live rig and a video:

APC40 Customization from Darren E Cowley on Vimeo.

The “short” film clocks in at nearly eighteen minutes, but here’s the basic ingredients:

Korg padKONTROL + the free Farmpad customization tool for Mac + Akai APC40 + the mighty, powerful Bome MIDI Translator for more control over events + the now-discontinued Lucifer VST (which I believe has now been replaced with the audio-recording-manipulating Live Sync Recorder.)

There are some really tasty hacks here. Scene launch buttons glitch the sound or impact launch quantization. Controls provide quick access to recording and playing audio loops. Effects are on summed tracks for DJ-style effects manipulation. There are clever tricks for using lights for additional feedback. It’s all proof that no two people really approach Live or even this fairly clearly-mapped hardware in the same way.

Side note: I received a comment from a gentleman who is color blind and therefore can’t see the red/green light feedback on the APC40. Anyone with tips? I don’t think you want to rip out the APC’s lights, for sure. It does really prove that one size can’t possibly fit all in hardware.

Here’s a superb reader tip: DJ Josef Prusa has been using SugarSync to synchronize Native Instruments’ Traktor Pro DJ software, so that he and his brother have their full music collection at the ready at gigs. (Naturally, this same technique means that if one of their MacBooks should die, bro to the rescue!) Not only does music get synced, but playlists, collections, MIDI mappings, and settings do, too. Now, you could use something like the ubiquitous free command line utility rsync to do the same thing, but SugarSync has the advantage of giving you cloud storage, too, so you have an additional backup and always-on access to your files.

Traktor is just one example. You could do the same with any other essential files. Josef also syncs Max/MSP patches for monome, plus a promising-looking, in-progress wifi controller. File sync in SugarSync works across Mac, PC, and now iPhone, Windows Mobile, cell phones, and Android. (One gripe: no Linux support, something DropSync can muster.)

Synchronize multiple collections of Traktor PRO automatically

Before this becomes a SugarSync ad, though, I am interested in what other solutions people are using. There are various cloud storage and sync services. SugarSync is fairly unique in providing both true sync/remote access with cloud storage. But maybe you have added your home server to the mix, or found another solution.

Josef seems to be the perfect geek DJ – check out his iPhone-MIDI hack and (while not musical) iPhone R/C car control.

When software has “Live” as its name, you know control will be everything. So it’s great that many control surfaces will behave intelligently out of the box with Ableton Live, including devices like the Akai APC40 and Novation ReMOTE SL. If you’ve used one of these products, you’ve no doubt been able to click a device rack in Live and have a blue hand icon appear in the title bar, automatically assigning, say, the first eight macro knobs in a drum rack to your eight hardware encoders.

But what if you have hardware that isn’t covered by this functionality that you want to use? The easiest solution is something called MIDI Remote Scripting. It’s been available since Live 6, but it seems not many people know that it’s there or how to use it. It’s not a perfect solution, but it’s such an easy hack that it’s worth at least exploring.

For this tutorial, I’ll take the example of the Korg nanoKONTROL and nanoPAD. They’re a likely candidate, at about US$60 street each and with some handy controls (kontrols?) for mixer channels and drum racks. But you could take any hardware and apply the same technique — even something you’ve built yourself — so long as it sends simple MIDI messages.

The upshot: you get simple “automap” functionality without something specific like Automap (or drivers, in general).

Required for this tutorial: Ableton Live 6.x or later. I’ve tested only the full version of Live on Mac and Windows, though I think at least some of the “lighter” versions should work, as well.

This is a long article but a relatively short and easy process. I’m just giving you everything you could possibly want to know about the nanoSERIES and MIDI Remote Scripting!

Introducing MIDI Remote Scripts

Ableton Live uses compiled Python scripts to provide custom support for controllers, as I understand it. I’ve never looked into this specific functionality, and generally you wouldn’t unless you’re a hardware vendor working with Ableton.

As of Live 6, though, there’s a hack provided for everything else, called MIDI Remote Scripts. They’re simple text files that let you specify mappings of MIDI note, Control Change, and channel messages to common parameters in Live. This text file is compiled into a Python script for the hardware when Live launches. Basically, the Remote Script covers:

• The 16 visible pads in Drum Racks
• Device Rack encoders (the 8 Macros for each Device Rack)
• Bank parameters for switching between banks of encoders in devices that aren’t in racks
• Volume faders 1-8, plus the master volume setting
• Sends for tracks 1-8 (just the first two sends)
• Track arm buttons for recording into tracks 1-8
• Transport controls

Now, if you’re not familiar with Device Racks and Drum Racks, and how to use them for instruments and effects, you should absolutely go brush up now. Really, go ahead – I’ll wait. The rack functionality introduced in Live 6 is essential, because it allows you to take complex sets of effects and instruments and map them intelligently to just eight controls.

You’ll notice there’s plenty of stuff that’s not on here. There’s nothing to do with clips. There’s no way of banking up to track counts higher than 8. There’s no way to easily bank between sets of pads in Drum Racks with more slots. There’s no headphone level. There’s record arm, but not track enable/disable. I could go on…

But you do get a pretty decent base set of functionality if the list above looks appealing. Since you’re just using MIDI, you can manually assign any additional remaining hardware MIDI controls to your favorite parameters.

And the most important thing about all of this is that parameters for the Device Rack are dynamic. So while there are eight of them, that covers any selected device anywhere in your set. Click on the device, and the blue hand lets you know the device is under your control. Whichever controls you’ve chosen — say, eight huge mechanical knobs on a DIY hardware controllers — will map automatically.

Finding and Editing the MIDI Remote Scripts

I do mean finding. Your first job is to find the MIDI Remote Script location on your drive.

First, here’s where it’s not: it’s not in the Ableton program folder itself. There is, in fact, a User Remote Scripts folder in there, but it’s not the one you want to use. (I bring this up only because I tried to put my customized text file in that folder, had my script show up in Live’s preferences, but then couldn’t understand why nothing was working. Learn from my mistake, and be wiser.)

Instead, you’ll want to navigate to your user preferences folder.

On Windows Vista/Windows 7, my Live preferences live in:

[Windows boot drive] > Users > Peter > AppData > Roaming > Ableton > Live 8.04 [or your version] > Preferences > User Remote Scripts

(Yours may be in Local rather than Roaming, depending on whether you installed Live for all users. On XP, the path is similar, but in your boot drive’s Documents and Settings.)

On Mac:

[Library folder] > Preferences > Ableton > Live 8.04 [or your version] > User Remote Scripts

Note that on the Mac, in similar fashion to the Remote/Roaming difference on Windows, you may need either the Library folder at the root level of your boot drive or the Library folder inside your user folder (the one you see when you click Home, Documents, etc.).

You’ll find two files in that folder. One is a how-to text file, as pictured above, though it doesn’t tell you that much. The other is a sample file.

To create your custom script, you’ll want to duplicate the UserConfiguration.txt script and place it in a folder with the name you want to appear in Live. So, for my custom nanoKONTROL script, I have:

User Remote Scripts > nanoKONTROL > UserConfiguration.txt

Note that the new file will still be called UserConfiguration.txt.

Customizing in the nanoSERIES Editor

Let’s take a quick side trip to set up our KORG nanoSERIES controllers the way we want.

Out of the box, the KORG nanos don’t come with any software disc, because you don’t need them – just plug them in, and they work. And, in fact, if you’re happy with the default MIDI assignments, you never need to go beyond this. In this case, though, I was interested in remapping some stuff, particularly on the nanoKONTROL buttons, so I went ahead and started editing.

You can head to the Korg Nano site and navigate through support, or even easier is to head to this direct link:

Support Results for nanoSERIES

(If you’re outside the Americas, there may be a different link.)

Click Downloads and choose Kontrol Editor for Mac or PC. (You may also want to grab KORG’s own USB MIDI Driver.)

The Kontrol Editor is really quite nice to use and surprisingly powerful for a $60 piece of hardware. At the top, you’ll see buttons for the scenes on the nanoPAD and nanoKONTROL. There’s a visual representation of the controller which, by default, displays MIDI Control Change and note number assignments. (To change what this preview displays, select the dropdown just below the picture of your nano.) The Browse tab allows you to navigate your file structure, but keep Control selected to change assignments.

You can safely ignore the boxes above the controller for now, which control scene settings and channels. Instead, focus on everything on top of and below the controller. On the nanoKONTROL, the faders’ CC assignments are just below the faders. (Look carefully; that can be a bit confusing at first.)

I’m providing my download of my template, so you don’t have to muck with this, necessarily. But here was my strategy:

nanoKONTROL I was most interested in reassigning the buttons next to the faders. Selecting “Momentary” lights up the button only as you’re pressing it; “Toggle” has it turn on and off. Note that this doesn’t actually impact the messages it sends; just the lights. For Scene 1, I wanted these buttons to double as triggers for my drum pads, so I changed all of them to Assign Type: Notes and adjusted Button Behavior to Momentary. For the remaining scenes, they’re record arm buttons, so those I left as Control Change assignments and Toggle behavior.

The tricky part of this is that KORG has nine faders and encoders instead of eight, and everything in Live is grouped in eight. I made the ninth fader a master. You might manually assign the knob above that ninth fader to headphone out.

nanoPAD All the fun in the nanoPAD editor is to be had on the X/Y controller. The two boxes that are pre-assigned represent X control and Y control on the pad. The third box allows you to define an additional controller for touch across the whole pad. On the pads themselves, note that you can assign up to eight(!) control change or note messages, not just one.

For this project, I just wanted to adjust the note settings to map more intelligently across my Drum Racks, which I’ll explain with the download. That means, unfortunately, going through one by one and changing pitch assignments. For the pad, I’m of two minds. You can keep those CC assignments consistent across all four scenes, or use each scene to control different parameters for a total of eight (conveniently, the number of macros on a Live Device Rack) Note that the scene descriptions at top are just text you add, so the “Drum Kit” or “Chromatic” labels are really just suggestions; they have no functional purpose. You can change them if you want, but the editor is the only place you’ll see them.

User Configuration Settings

Lastly, let’s walk through the changes to make to UserConfiguration.

[Globals]:

For InputName and OutputName, it’s essential that you match exactly the text listed by a MIDI device when it’s connected to your computer. For the nanos, that’s “nanoPAD” and “nanoSERIES.” You can verify this by opening your Live preferences and checking under MIDI.

You also need to double-check your GlobalChannel. Numbering starts at zero, so channel 1 is channel 0, and 10 is 9. You can plug multiple nanoSERIES devices into a USB hub — even an unpowered hub, the power draw is so low — so I like to assign different channels to different devices to avoid confusion.

In the rest of the document, any channel that references “-1″ is equivalent to the default. For that reason, I recommend leaving channel assignments along and just changing the default global channel.

Pads and Device Controls

Here’s the fun part: you can set up pads and Device Controls (Macro) encoders to dynamically control the active device. Choose note messages for the pads, and Control Change messages (with the associated numbers) for the encoders.

Here’s the trick: you need to have everything assigned, or it won’t work. In other words, you can’t assign just the first few encoders or just the first few pads, or, oddly, Live will refuse to recognize this as a mappable device.

Banks and Locking

I didn’t find Banks as useful. Banks allow you to choose banks of unassigned controllers. That can get confusing, though, so I still recommend using Device Racks to manually pick and choose which macros you want assigned.

There is, however, an assignment for LockButton. This allows you to pick a button that will “lock” your dynamic controls to one device. So, for instance, let’s say you have a rack of effects you want to control with your nanoKONTROL. When you’re at home in the studio, you might want to mouse around and click different devices for tangible control. But live onstage, you want just one live performance effects rack. Lock the device, and you won’t accidentally click something else and lose control.

I didn’t assign this on the nanoKONTROL because there wasn’t a convenient parameter to assign, but you can still lock a Device from within Live.

[MixerControls]

This gives you limited automatic control of mixer levels (for channels 1-8), sends (1-2 for each of those channels), record enable (for arming tracks), and the master mixer level. I like having a master to control, so having that ninth fader on the nanoKONTROL wound up being very nice.

Now, it is a little annoying to be limited to eight tracks, but there are two important factors here. Firstly, this is a dynamic assignment, meaning you don’t need to manually assign anything or make a special Live session template. That means you can mix and match MIDI and audio tracks arbitrarily, which you can’t do with a template. Secondly, sometimes having the arbitrary limit of eight channels is ideal in live performance — and it means you don’t have to bank around.

Transport

This winds up working perfectly: you get play, stop, record, forward scrub, reverse scrub, and even a loop on/off switch. Of course, you don’t get some of the other parameters you get from an Akai APC40, like turning on and off MIDI overdub. But, hey, you spent sixty bucks on the Korg and you really can’t balance an APC40 and your laptop on Greyhound.

Setting Up Live

Once your MIDI Remote Script is in the proper folder, your device will show up automatically in Live. That’s especially cool if you’re a DIYer; you could have Maria’s Arcade Button Mashapalooza show up if you want.

Select a configured device just as you would any other control surface. Choose Preferences > MIDI/Sync, select Control Surface in the first column (nanoPAD, for instance), and then its Input and Output ports. Finally, enable the Control Surface Input for Track and Remote. This will allow you to manually override assignments if you want, and to assign controls on your hardware you didn’t assign in the MIDI Remote Script, both via the usual MIDI Map method.

Because I want to be able to easily record-toggle multiple tracks — and because anything else will mean the “toggle” lights on the nanoKONTROL are wrong — I also like to turn off “exclusive” arming in preferences. This way, you can record-enable multiple tracks at once, so that when you want to feed MIDI into your soft synth on track 7, your vocoded vocal track on track 2 doesn’t immediately switch off. Go to Preferences > Record/Warp/Launch > Record > Exclusive and make sure Arm is unlit. (Pictured above.)

One last tip, as suggested by Mike Hatsis of Trackteam Audio: use the Drum Rack’s Auto Select feature, and you’ll automatically toggle the interface to whatever part of the rack’s various pads you happen to trigger. (This works in Live 7 and later only.) This way, you can easily toggle more than the 16 visible pads. On my nanoPAD template, for instance, I’ve already gone to the trouble of mapping the remaining scenes, so the first 16 pads map automatically, and then scenes 2-4 can access other pad slots.

To enable Auto Select, make sure the Chain is visible in the rack, then click the small A button as pictured above.

Alternatives, Future

Now, go forth and have fun!

Granted, this isn’t a perfect control mechanism. If you need to bank more easily between tracks, control a whole lot of mechanisms that aren’t here, focus on clips, or … well, do anything other than the stuff described above … it’s not ideal.

On the other hand, I find this resolves about half of the situations that would otherwise require manual MIDI assignments and, worse, templates rather than dynamic assignment. For basic MIDI tasks, it’s a hack, but a useful hack.

What about the future? HyperControl from M-Audio and Automap from Novation both have more sophisticated integration. The Akai APC40 goes further than previous devices as far as dynamic clip triggering and shortcuts. And other integration is possible with Ableton’s own scripts than what you can do here, although you don’t necessarily get support for all the hardware you’d like to use.

MIDI Remote Scripting is frozen in time in Live 6, so as its own documentation says, there’s some stuff missing. I don’t expect it to be updated, however — too bad, as it is a nice hack.

The Ableton Live API is likely where future action is at. While it’s not an official or supported feature, I have no reason to suspect that it’s going away. On the contrary, you should be able to use API functions controlling clips and most functions of the user interface in Live dynamically. This functionality will be baked into Max for Live if you’re a Max user, but should also be accessible via the hacker-spported, community-based Python API wrapper. Most promisingly, hackers have already wrapped this Python API into both MIDI and OSC implementations, meaning you should have a choice between using Max for Live and supporting this functionality directly from hardware, even without M4L.

I’ll be documenting what’s coming very soon, both on the Max and Python/OSC sides. In the meantime, here’s a preview of what the API will do from our friend Andrew Benson at Cycling ‘74. Andrew is himself a visualist, so I expect we’ll see some nifty visual applications.

Max-for-Live: A Sneak Peak at the Live API features

And looking beyond even Live, I think we’re now in a world in which we’re finally moving beyond simple MIDI learn. That’s a big relief. Next stop: OSC.

KORG owners: Downloads coming in a separate article later today!

Corrections/tips: More to add? Let me know and I’ll update the story. -Ed.

Electronics and code and whatnot are great fun, but a lot of people want to know, how can they add actual, physical motion to a project? I’ve rounded up the last few odds and ends from the London Music Hackday organized in the offices of The Guardian, and came across Alistair MacDonald and Mr. Duck’s Percussion Machine, which uses Arduino with servos to strike beer bottles.

Here’s the perspective of the non-techie on the affair from the newspaper’s music blog:
Beats and geeks at Music Hack Day

Of course, I’ve heard from at least a couple of people that for this audience, you’re not entirely ready to do all your work in the cloud. APIs. Yawn – the computer musician audience still is happiest with as much CPU power as they can muster, live sound making in native code on a local machine, and, you know – rocking out. But that to me is a bit interesting in itself.

Also from the hackday:

While the Arduino is ideal for hard projects, software projects turn to the fuzzy textile-friendly Arduino LilyPad. (Side note: the LilyPad turns out not quite the perfect tool for all occasions, and a discussion of all soft electronics may be what’s next. But it is a good starting point.)

Rain Ashford used the LilyPad to make an interactive felt cat named TwinkleStarduino. Just don’t cross the streams – er, threads: “Yep – all the components are connected by conductive thread – none of these must touch each other or you’ll get a short circuit – which is a challenge in itself :-)”

Rain’s blog post discusses some of the challenges of the project and some of the things that went wrong, which I quite like. (One of the goals I set out for our own music hackday last month was to break s***.)

Musichackday 2009 – my hack: TwinkleStarduino [I like cats]

For fans of RjDj, the interactive music engine for the iPhone and iPod touch, here’s an example of the sort of work you can hack together in a day with the help of patching environment Pd:

ShakeNRoll by ookoi

Lastly, photos by organizer Dave Haynes:

And yes, it sounds like the EchoNest is interested in doing a hackday here in America. And with the help of the site we’re building, noisepages, we definitely plan more hackdays on CDM, too, with a CDM-style focus. Stay tuned.