WalkSX from Gijs on Vimeo.

As the Sony Walkman turns 30, many of the mobile cassette’s fans wax nostalgic. But it takes Gijs Gieskes to wire up a new Rube Goldberg-style musical instrument based on the Walkman’s simple tape playback.

Follow along carefully through the signal flow of this unusual instrument:

1. The Walkman has audio on the tape itself, sampled from a Roland TR-808 drum machine.

2. Because a compact cassette has two tracks (left and right, for stereo), one track is dedicated to the drums, another to the rim shot.

3. The rim shot track is fed as a mono audio input to an Arduino (the open-source microcontroller platform). The Arduino responds to the audio level, so each time a rim shot hit occurs, it ….

4. …sends a sequence event to the Gakken SX-150. That means that you can adjust the speed of the whole contraption by…

5. …adjusting the speed of the tape. (Bless you, analog playback!)

It takes Gijs to think that way somehow: put together, these elements are actually fairly simple, but strikingly effective. Fortunately, if this does inspire new ideas, Gijs has posted all his Arduino code, so you can check this out and try something yourself.

http://gieskes.nl/instruments/?file=walksx

Design in music in a digital world can be about the object as the sound – musical ideas translate from one medium to many others. And just when you think you’ve seen it all, someone comes up with a new visual metaphor, a new creation for manipulating music.

OTTO is a functioning prototype combining interactive hardware and computer software, the invention of Luca De Rosso. He produced the design as a thesis project for his masters’ degree in Visual and Multimedia Communications at IUAV University of Venice. It uses the Arduino open source hardware platform and Cycling ’74’s Max/MSP software, and Luca accordingly is quick to credit the assistance of those two communities. In that sense, two, I think it points to lots of new design in the field of integrated hardware and software – not just standalone hardware or standalone software or generic controllers for anything, but hardware that itself behaves like software.

All photos here courtesy Luca and used by permission; see his Flickr account.

OTTO ~ demo.01 from Luca De Rosso on Vimeo.

Luca sends along some more details of the behind-the-scenes workings just for us. (Thanks, mate!)

Luca actually had assistance from his father working on the case. (I love that – father-son collaboration!) All the electronics are on a single Arduino board, and the patch works in Max. (Max has features that make it well worth using, but it’d be nice to see a Pd port, too, making the whole setup open source – and giving you an easy way to run it on Linux.)

OTTO ~ Getting Started from Luca De Rosso on Vimeo.

Luca sends us a view of the innards of this device – you saw it here first:

The first prototype is done, says Luca, with three more coming in coming days as he heads to a festival in Croatia. Plans for the future: no commercial availability yet, but Luca says he’d be happy to hear from anyone interested in manufacturing. (Capital remains the big challenge, even as fabrication gets easier.)

I also love the way he’s designed the documentation. Music tech industry, please, this is how it should be done – with all due respect and without naming names, we really would love if you just showed us your gear and didn’t have some swarmy dude gushing about lots of hype. In fact, we’d be equally happy to buy your gear if the design spoke for itself rather than having your name and circuit diagrams and random text plastered all over it.

But this is really visually inspiring, creative work. And to top it off, it looks insanely fun to play. Putting the beats in a circle opens up all kinds of other possibilities, and suggests thinking in terms of cycles rather than the grids we see on other hardware. As with the monome, you can imagine other software applications that would hook into this basic, minimal hardware design. I hope we see more of this design and concept.

http://www.lucaderosso.com/otto/otto

More videos:

OTTO ~ demo.02 from Luca De Rosso on Vimeo.

OTTO ~ demo.03 from Luca De Rosso on Vimeo.

Artists Gijs Gieskes’ sequencers are almost like physical, mechanical software, an expression of musical structure in object form. As such, even as they make strange sounds, they become musical sculpture. His latest Servo Sequencer combines optical and mechanical process, as frequency circles spin on a turntable and tone arms float above them.

The Servo Sequencer is built for exhibition use – meaning, yes, he’s brave enough to let you play with this contraption. Sequence the arms using buttons, then adjust the volume mix and placement of each arm using the joystick.

Serv Seq from Gijs on Vimeo.

This project is unusually well-documented. Gijs provides complete specs, the script that controls the arms, and even a little web app that generates those lovely patterns.

http://gieskes.nl/instruments/?file=serv-seq

But for those of you near the Netherlands, you should go check this out in person. Updated: The piece will be part of an exhibition in Breda through August 23, with multiple opening events featuring local artists from Eindhoven and Breda, plus live performances and concerts including Gijs and his talented brethren and neighbors.

Here & There Exhibition, mu.nl [Info in English]

The events:
Opening Part 1:
KOP, Breda
Thursday 25/06 08.00 pm

MU, Eindhoven
Friday 26/06 08.00 pm

(It’s a bit confusing as the events swap between Breda and Eindhoven — there’s a second opening Saturday July 25. Gijs explains “the first [opening] is in breda (thursday), then a day later (friday) in eindhoven, where my machine will be. and then a month later its the other way around.”)

You know, Breda. Like, right … here. We’ve got a number of readers in the area (whom I suspect know more or less exactly where this is); let us know if you make it!

Forget NAMM — one of a handful of hardware I’m most excited about in 2009 is all DIY, the 8-step GorF step sequencer. (I’m hoping for follow-ups like a Forg or Grof. Kermit (Muppet) fans know what I’m talking about.)

With four sequences with parameters, steps with pitch, gate, and Control Change, sequencing controls, legato mode, and the planned ability to both send and receive clock, this is one useful-looking device. And from the video above, it looks like it’s progressing really nicely.

In fact, if you think about it, it’s kind of puzzling that there isn’t a simple, cheap, commercial device that does this. As a kit, though, people could hack in features others might not imagine, it could be combined with other DIY and open source synth and music projects, and it makes a great kit and learning tool — meaning it’s more fun, anyway. And if you want a pink case, you can do that, too, but you can decide whether you want it more salmon or fuchsia.

Paul, do keep us posted!

Via musatkl / nostromo.

Here’s something I’d very much like to see: a hackable, kit step sequencer.

nostromo tips us off to a blog item on his site on the project. The creation of Monowave maker Paul Maddox, the 8-step sequencer is based on an Atmel Mega16 micro chip. The whole thing is looking very compact, which could make a nice little unit or might integrate well with other projects (like a synth).

The other good news to me: new DIY hardware could be a great way to run clock into software. Previously, that job has fallen to somewhat dull consumer drum machines. With DIY projects, even software lovers may soon be hacking new features into hardware and manipulating software sequences with that.

Planned features include “rock-solid timing” (sounds good), plus:

• 4 sequences with parameters
• Steps with pitch, velocity, gate on/off, and two Control Change messages (CC1/CC2) on a selectable channel
• Adjust tempo, base note (including via MIDI), sequence and step length
• Legato mode
• Send MIDI clock out, MIDI sync in (currently input isn’t done – input is usually trickier than output, but output may actually be more interesting to people)

nostromo already has some ideas for how to make this interesting when combined with chip trackers like LSDJ and LPGT, so worth reading his original post (thanks!):

Meet Gorf [mustakl]
GorF Project Page at Paul’s site Vaco Loco

Anyone out there worked on a similar project? (I’d sure love to have a DIY sequencer or two at our Handmade Music events in NYC!)

It’s hard to write the first line of this, because in this case any reference to Kraftwerk’s “Pocket Calculator” is wildly redundant. This is a calculator. He is the operator. This is a real, working HP48 graphing calculator playing MIDI events. You can go, like, graph stuff with it afterwards, do some Calculus. And we can thank a few people responding in a mobile music poll on this site for making it happen.

Andrew Turley, who has previously built a microfiche MIDI machine (thus making his way through arcane academic equipment as MIDI controllers), describes the project:

This is a demo of a project I built so that I could use my HP 48 to play a MIDI keyboard. The calculator is running a program that sends data to a Parallax Stamp Basic microcontroller over the built-in serial port whenever I press a button. The microcontroller is running software that converts the message from the calculator into a MIDI noteon or noteoff message that is then sent to the keyboard. This is a response to a createdigitalmusic.com poll in which a (small) number of users said they wanted the site to cover more calculator music.

Brilliant work, Andrew. And I have to say, now that you’ve done it, it’s a pretty practical little object to us as a controller.

Other calculator work, anyone?

Marc “Nostromo” Resibois, aka “m.-.n,” lives the digital life of computers. The Belgian musician and hacker [@MySpace] is renowned as a Game Boy musician, as the inventor of legendary Nintendo tracker LittleGPTracker, and even has a day job as a programmer for VJ software maker Arkaos. But lately, his thoughts have turned to more traditional synthesis hardware – hardware that acts as tiny computers. Nothing is going to shake me from my love of computers, but that doesn’t mean I’m not interested in having what he describes sitting next to mine. Here’s what he imagines – and it’s a variation on a theme I think we’ll see a lot in the coming weeks and months here on CDM. And without giving away the punchline, that Nintendo DS is going to make another appearance.

I’ve always loved small, self-contained units. Because I’m a software guy, I’ve been developing music software on handheld consoles for years. I love these little guys. They are tiny, fairly powerful, and their physical interface gives you a good amount of control, leading to a growing stack of interesting applications.

However, recently, a couple of interesting projects started to emerge from the hardware side of things. That makes it possible to start dreaming about building your own little synth, even for people like me who can’t even deal with sticky tape.

My first hands-on with hardware was when I started fiddling with the Arduino piano. You might argue that once it’s built, it’s still software platform, but I really enjoy working on this bit of kit. The interaction is even more straightforward than game consoles: press a button, turn a knob, and get sound. Although it might seem limited compared to software synths, it also has dimensions that a lot of virtual instruments lack. I’ll call these qualities depth and exclusivity.

Depth: When you turn a pot on this hardware, you’re really in control. You may argue there’s a lot of controllers out there, but compared to the 1024-level resolution of the Arduino, standard MIDI Control Changes turn out to be bogus for smoothly controlling parameters. Just playing with the default FM patch of the Arduino piano makes it obvious. [Ed.: Of course, I will add there are ways around this – higher-resolution MIDI control messages, plug-in automation, OpenSoundControl, and audio-rate / audio-stream control, to mention a few, not to mention even simple interpolation of lower-resolution MIDI controll messages. But then, we’re talking a very, very cheap piece of hardware on the Arduino, so there’s a big point here. –PK]

Exclusivity: When you play with hardware like the Arduino piano, it’s the only thing you do. You can’t fire Google or start reading your mail, and I think it’s really valuable. Every music "tool" should be able to immerse you enough so that the rest of the world doesn’t exist. All computer-based synths have failed to do that for me.

Of course, the greatest thing of all is that this domain is only at its very beginning. It’s a small spore in your hands waiting to morph to the next level. You decide its fate. And that’s where it gets exciting. Playing with the Arduino piano and looking at it as a synth development platform, I started to think about what I could dream of making with it. What would make it "timeless" for me, using existing available technology?

Here’s what I ended up with:

1. The core: At this point, it doesn’t really matter if we’re talking Arduino, Propeller or any other chip. The point is that there are programmable chips out there that will support development of your very own personal synth. They might run at very low sample rate, they might have the tiniest memory for programs, but they have soul. In the 80s, when digital synths hit the mainstream market, they were likewise limited in resources. Still, they were powerful enough to be admired and loved.

2. The engine: Ideally, the processor should be fast enough to allow a fairly configurable synth engine — something that would allow switching between ‘presets’. You don’t want to have to flash the chip every time you want a new sound. It doesn’t take a major CPU to be able to do something decent. For proof of that, look at Korg’s DS-10 running 6 parameterized synths on a lowly Nintendo DS. Maybe the Arduino is too limited to be a good enough candidate for this, but there are plenty of other possible platforms.

3. Controllers: As I already mentioned, direct hardware control is a joy that can’t be overstated. Having high-resolution pots connected directly to the chip provides an easy and cheap way to tweak your sounds in real-time, in ways you’ve probably forgotten (assuming you haven’t recently used analog hardware and the like). Let’s call them generic controllers: we want them to act in the most expressive way depending on the ‘presets’ that were built for the synth engine.

4. The keyboard: It doesn’t take long playing with the Arduino piano to realize the keyboard is not going to take you very far. Not being a keyboard player myself, my idea is to ditch it and keep a few switches for direct action like switching patches, transposing, etc. I’m pretty sure there should be a way to integrate a decent keyboard in this setup, but how to do that is beyond my reach. One could trigger the sound with just a button. A few pots and a “push me” button – sound familiar? Ed.: See the Dave Smith Mopho, though generally people are hooking MIDI keyboards to it so they can easily input pitch. But then, why use a keyboard at all? Quite a few synth lovers regret the addition of keyboards to synths, because they don’t allow for expression between notes, as on instruments like violins or the human voice. I’m not sure a single button is an improvement, but then, you could create the architecture of the synth to easily allow analog input, thus enabling anything you want. -PK

5. The deep end: This is where it gets fun. So far, we’ve got something fairly basic — running a synth on a chip, triggering sound, and having patch-based control on expression parameters. What could make this synth totally self-contained would to some means for editing sounds from the unit itself. There was a recent post on Analog Industries wondering whether people preferred a simple interface or access to all parameters. In my view, an ideal synth should provide both: when editing a patch, you should get access to all the parameters. When playing it, you should get access to only those parameters that make sense for the sound. The first example I remember of this is the Nord Modular: it provides modes geared for a sound designer or a performer. That’s true with the wonderful morphing effect rack in Ableton Live or the generic parameters of the aforementioned Mopho. But how to do this in a small, self-contained unit? The pots give us a performance mode, but the challenge is how to navigate the deeper possibilities of editing a synth engine? I just don’t want to have to use a computer. I’d be checking Facebook or uploading moods to Twitter instead of making noise.

There happens to be a mobile, compact unit that could be perfect for the job, however: the Nintendo DS. It’s got a small form factor, a few additional hardware controlers, a very playable touchscreen, and a serial interface that could enable bi-directional communication with the synth engine. By throwing the NDS in the picture, we could gain:

• A user interface to edit the synth’s parameters (why not implement a touchscreen based VCS3 type matrix, for example?)
• The possibility of running a small sequencer
• Some additional performance capabilities, a la Kaoss Pad, to control the synth.

So in the end, we have a hardware/software hybrid that’s very powerful, yet fits in a very small form factor, and whose cost (beside the blood, sweat, and tears of building the whole thing) wouldn’t go past the USD 300 mark.

Anyone with too much time on their hands? I’d like one, please :)

Ed.: Some really interesting ideas here. I’m not sure I’m so crazy about the Nintendo DS as a closed platform, though. Reimagine this more broadly as hardware DSP / embedded microcontroller synth engine plus some sort of small mobile computer, and you’ve got lots and lots of possibilities. I’m not tossing my computer – I can close the Internet and focus on music for a while even on a computer – but even as a lover of sound design on a computer, I find all of this very tantalizing. I also know we have some other folks working in similar directions and on other mobile ideas, so stay tuned. -PK

I received my Arduino Diecemila in the mail last week and have started to experiment with using it to synthesize audio and video. I’m not very experienced with programming microcontrollers, so I’ve been doing a lot of research to see what’s out there, and it’s greatly encouraging to see that people are taking this little kit in fun directions.

While I wasn’t able to find many “finished” projects, I did find a whole lot of ideas that deserve further exploration:

First up is a simple but effective “Arduino Theremin” from Alberto Bietti. Looks like this one uses an ultrasonic rangefinder rather than an RF field to effect pitch. The squelchy FM-like tone is a little screechy but could work well with a little bit of filtering:

Here’s a very nice MIDI Sequencer from beamercola, being played by IDM darling Tycho. The LEDs are a nice touch, and the stability as he ramps up the clock indicates a solid design. The end result is extremely musical and could stand on it’s own alongside some very pricey commercial counterparts:

Here’s a circuit-bend from octopussss using the Arduino to adjust the toy’s clock rate. Super freaky:

Sebastian Tomczak of little-scale has a very promising drum machine design. I’m sure he’s working on a newer version that doesn’t use those terrible DIP switches for controls:

Sebastian’s also got an amazing VGA synthesizer rigged up that is controlled by what looks like MIDI data synchronized to a beat made in Ableton Live. So awesome, and very portable. I could use one of these at my next live gig:

On a related note, here’s a project from iperry that uses the Arduino to separate incoming audio into frequency bands, then uses those signals to control the color/brightness of a few ambient orbs. Nicely done:

What’s great about these projects collectively is not their functionality, but the breadth of their intents. I’ve yet to see a fully functional polyphonic synth powered solely by Arduino, but I think we’re seeing the components of such a system coming together one by one. And because the Arduino is open-source and nearly all users share their data and experience, we’re only going to see more and better projects as time goes on. I think we’re just at the start of a long journey, one that will certainly delight and amaze as it unfolds.

Ed.: Terrific finds, Mike! But I’m surprised — you missed one of the biggest projects. It’s not polyphonic, mind, but it sounds fantastic. The Critter and Guitari folks, whom we already loved dearly for their video synths and organs and DIY video kit, have built a shield for the Arduino adding on synth capabilities. -PK

This is a board for making the Arduino into a portable stand alone music synthesizer. It plugs directly into the Arduino board and provides 25 multiplexed keys (2 full octaves), 4 pots, status LED, reset switch, digital to analog converter IC, and a RCA audio jack. The Arduino board with its powerful AVR processor is more than adequate for a wide range of sound synthesis techniques. We have experimented with additive / wave-table synthesis, frequency modulation, ring modulation, sampling, polyphony, various arpeggiators. The whole thing can be powered over the Arduino’s USB port for convenient experimenting.

Pocket Piano Arduino Shield Project Page

Here’s a hands-on demo, as captured by Make’s Collin Mel Cunningham :

My favorite project — the creators built a housing and fuzzy keyboard membrane out of felt, as pictured at the top of this story.

Felt Pocket Piano Enclosure How-To [Critter and Guitari]

Collin walks through the whole process of making the Pocket Piano project on MAKE:blog.

Build the Arduino Pocket Piano

Collin has also tried building his own synth project, as reported previously on MAKE.

I’m guessing that, with the Pocket Piano out for a few months, there are other projects we’re missing. So, fair readers, if you do have cool Arduino-based projects of any kind — or, for that matter, want to tell us that you really prefer a different kit or microcontroller platform — we’d love to hear from you! -PK

Not happy with what you can get off the shelf? Build your own. That’s increasingly the philosophy of people working on music hardware. But a second economy is growing around these unique, boutique projects. By open-sourcing the designs, they offer the opportunity to build upon their work, buying something from a small group of designer-musicians and then modifying it to your purposes. The latest addition is the Aurora, which just became available for sale this week. CDM got an exclusive hands-on look at the new hardware and a chat with one of its designers. Here’s our first look at open source hardware’s newest musical gadget.

The Aurora is called a DJ “mixer,” but it’s really a control surface. It connects via a USB jack for power and to transmit serial-over-USB data, then uses free software to translate that data to MIDI messages for use with software like Ableton Live. The project is the work of a three person team, with Matt Aldrich designing electronics, Mike Garbus designing firmware, and Maro Sciacchitano working on the form factor and look and feel. They have an impressive background in making stuff. I got to hang out with Matt in Boston, where he’s joined MIT’s Media Lab Responsive Environments group, so I expect more good projects out of him soon. Matt and I talked frankly over coffee and pastries about the strong suits, weak spots, and future of the device and other projects.

Kit Availability and Pricing

Availability of the first aurora224 model was announced today:

• Complete unit: This kit requires only basic assembly. The PCB is pre-assembled, as are top and bottom panels, and all parts are included. Basically, you just put those panels, boards, knobs, and button caps together using a hex screwdriver — no soldering required. US$340.00. ($420 international)
• DIY kit: This is the one with all the soldering — not recommended if you’re new to soldering, as there’s some tricky stuff in there. US$270. ($350 international.)

Aurora Mixer Project Site
Order Page
Previously: Aurora: Gorgeous, Open Source DJ-Style USB Controller; Details from the Creators

You don’t get that much of a price break via the kit, so I expect you’ll only want to do that if you really enjoy the smell of solder as much as I do.

Onto the hardware itself:

Hardware

The Aurora is configured with DJs in mind, though it could also serve as a nice control surface for DJ-style mixing for laptop musicians, or as a controller for visuals. (I like the two-channel layout for visuals, so I’m quite eager to work on that.) Unlike something like Livid’s Ohm, it has mixing functions only, not triggers of any kind — but that could make it an ideal companion to a Korg kontrolPAD or (in the open-source spirit) Monome.

The controllers:

• A/B crossfader, with two channel faders (ideal for 2-channel mixing)
• 24 backlit knobs (ideal for EQ, effects)
• 8 backlit buttons (could be used to switch on and off effects or for other purposes)

The controller layout is likely to be the real draw for some. What’s especially nice is the spacing of knobs, which never feels too cramped. For people who like lots of effects control and simple two-channel mixing, it’s about perfect.

It’s important to note what’s missing: the unit doesn’t come with any caps for the faders and cross-faders. I think you’ll certainly want some, which may mean sourcing extra parts from a DJ maker or fashioning your own. Of course, part of what makes these projects interesting is customizing them, so if anyone has good ideas for unique fader caps, I’d love to hear them. Unless you enjoy the feeling of somewhat sharp bare metal, though, this is something you’re likely to want to address pretty quickly.

Form Factor and Lighting

The other aspect of the Aurora’s design that gives it less of a finished feel — though it looks fantastic — is the fact that the case isn’t fully enclosed. The top plate and bottom plate are both beautiful, and it’s lovely actually seeing a bit of the PCB. But that means the USB connector is a bit exposed, and the PCB and bottom plate are open to dust and the like. It’s very, very pretty, but you’ll need a way of enclosing this for transporting it around. I got to talk to Matt a bit about that; we didn’t come up with any perfect solution, but there are plenty of possibilities for those who want to come up with their own enclosure ideas. Ideally, you’d stick with the clear plexiglass-style solution as that’d keep the look right, but it is likely to be expensive to get that made to these specs.

Part of the reason for the clear baseplate and design is to allow the LEDs to show off nicely. In a darkened room, they look really fantastic. The LEDs on the base are pretty simple — just one red, green, and blue LED — but they’re adjustable, and bright enough that when bouncing on the base they do provide a nice effect. There are also dim color bands around the knobs. You can control the LED lighting in sync to music using the included software patches.

Note that these pictures (and Aurora’s video) are of the prototype, which featured engraved labels. I quite like those, but to keep costs down, the shipping units use silk screening. Haven’t seen those results yet, but I’m promised they look good, too. I’ll post a photo if we can get one.

Bundled Software

Like many DIY microcontroller projects, the Aurora communicates with a computer using serial over USB — that is, it doesn’t behave like a normal USB device. It plus in via USB and receives power over the USB bus. But you need special drivers to make it work on Mac, Windows, and Linux, which work by allowing your computer to see it as a serial device even though few computers today (and no Macs) have actual physical serial ports.

For a sense of the setup, have a look at the Windows and Mac setup guide. The most important ingredient is the virtual COM port drivers from the chip maker, FTDI:

Virtual COM Port Driver Page

For Windows Vista, I installed the “setup executable” option 2.04.06 at the top of the list; for Mac OS X Intel I downloaded the special Mac 2.2.10 driver. That works perfectly; on Windows, for instance, the Aurora installed like any other hardware and showed up as COM7. (This process should be familiar to anyone who uses the Arduino; the Aurora is not based on the Arduino but uses the same virtual serial setup.) I haven’t tried Linux, but there are Linux drivers available and the process is fairly similar. (Linux users could also use the available Pd patches.)

If you’re handy with patching or coding, you might be done at this point — you can fire up Processing (cdmo tag | cdmu tag) and talk to it using the serial library. (I’m going to try working on a serial library for the Aurora; stay tuned.)

But, of course, since that will only be a minority of you, the Aurora team have created some software that’s intended to be relatively friendly. The software receives incoming serial data and sends MIDI messages to your software of choice. That means you need a way of routing MIDI between applications — think MIDI-Yoke on Windows or the built-in IAC bus on Mac OS X. (I think I helped out the developers a bit on how to use the IAC bus, because those instructions are now included in the docs!) Once you can do that, though, you can use the Aurora just as you would any other MIDI controller.

There’s an added feature, as well. Using ReWire, the Aurora can add some tempo-synced lighting effects by receiving tempo information from your software. So, for instance, you could fire up Ableton Live and have custom, flashing lighting in time to your music. I would be even happier to do this with just MIDI clock rather than ReWire, as I don’t think the timing is quite critical enough to necessitate ReWire; I hope to have a patch that does MIDI clock soon.

The software is all built in Max 5, but it’s compiled for Windows and Mac so you don’t need to own Max 5 to use it. There are also Pd patches, which keeps your software open-source — it’s worth downloading the free Pd-extended for your OS of choice to play with them. And if you do own Max 5, the Max patches are editable, as well. That naturally means you could also directly interface the Aurora with your Max or Pd patches for controlling stuff you’ve built.

Using it with Ableton Live

I was curious to learn more about how the Aurora team actually make use of this device. After all, often the best creations are the ones designers build for themselves, not for anyone else. Matt showed me a basic 2-channel Live setup, pre-mapped to the Aurora. I convinced him to release that set as a template, so it’s now downloadable in the files section of the Aurora site. You can see how they’re making use of it: two channels, EQ, effects. If that’s your preferred mapping, you can even make use of this template directly. Of course, it’d be equally as possible to customize it or make assignments for software like Traktor, FL Studio, or whatever you want. (I’m going to give mappings for Kore a try for our Kore minisite, which will be an excuse to create a “DJ” rack for Kore.)

You may need to adjust the template to properly receive data.

Here’s a video from the Aurora crew of the results in action:

aurora Open Source DJ Mixer\MIDI Hardware w/ Ableton Live from mcubed on Vimeo.

Impressions

The Aurora really is something special; you can tell that it’s not the typical store-bought controller and people do respond very well to it. Also, while there are control surfaces with cross-faders like Novation’s adorable Nocturn, I can’t think of anything (amazingly) with this particular, balanced layout of effects controls and two-channel mixing. And it really is open source: the enclosure specs, schematics, firmware, and computer software are all available for editing.

It’s important to acknowledge that the Aurora was built as a DJ control surface, and built for MIDI. Messages transmitted over the USB port are all MIDI-formatted, so what this isn’t is a blank-slate control surface using OpenSoundControl like the Monome. It’s really MIDI first.

Those things said, I think it’s worth noting both the Aurora’s strong and weak suits, having played with it for a couple of weeks.

Strengths:

Put simply, this is a very nice controller layout. People who want it are likely to be attracted to the Aurora; people who don’t will obviously move on. The difference is, as an open, DIY project, instead of that decision being made by a large manufacturer, it was made by a group of tinkerers who have opened up the fruits of their laborers to the music community.

The open source nature should make it possible for those in the know to do unusual things, like add a tilt sensor or other things that wouldn’t be possible with a store-bought unit.

The Aurora looks gorgeous and unique, and I really love the exposed design aesthetically — if you can find a way to safely enclose the case.

The controls feel great, too — the knobs aren’t anything particularly special, but the buttons are wonderful and the tension on the faders in particular is nicely tuned. That is, if you can add caps.

Caveats

The biggest caveats have to do with MIDI and serial. By using MIDI, the Aurora doesn’t differentiate itself much from existing commercial MIDI controllers – and making matters worse, you will have to deal with an additional piece of software to route that MIDI into your computer. The arrangement works, but it’s slightly less convenient than having real MIDI drivers. It would be nice, given the need for software between the hardware and your software anyway, if the Aurora used something like OSC and translated that to MIDI. That’s something we might see on future projects.

The other issue is the fact that the form factor isn’t really quite finished. The case is exposed, and you don’t get caps for your faders. That might be a deal breaker, except that with this kind of hardware, you almost don’t want a finished product — the fun is in finding ways to customize the unit. But by the same token, I wish the design made this a bit easier. There’s almost no clearance on the edges of the faceplate or around the screws, and the lovely-looking curved edges would be hard to work into a design. My guess is that you’d sort of build a clear box around the thing. I’m interested in the problem, so I’ll be investigating and asking around some people I know who have worked on these kind of projects — and we certainly welcome your feedback.

Lastly, though it’s a niggling point, I’m not in love with the knobs, I think partly because I’ve been spoiled by the amazing encoders used on Native Instruments’ Kore controller. I don’t mind the lack of EQ center indents, because I can’t imagine using them that way, but that may also be a small drawback for DJs.

Open DJ

The image above sums up what makes the Aurora different from other controllers — and what outweighs some of its current weak spots. Courtesy the Aurora Mixer project.

Despite these weak points, it’s a really remarkable piece of hardware, and one you can get right now and immediately open up and reprogram / repair / rework if you wish. The real test will be to see how people respond to its open-source design, whether that translates into people using it creating some of their own solutions to housing, customization, and software operation in the way they have with some other open projects.

In other words, Aurora isn’t perfect — but that’s actually kind of terrific, because it’s something more important: open.

And I have to point out, the price is very appealing. I really do hope this is the beginning of more open source hardware to come. The key to me will be establishing strong platforms for development (Arduino is a start, as are microcontrollers like the PIC18LF4525 used here) and better models for fabrication, enclosures, and distribution that help keep costs down and (ideally, to support people doing development work) bigger margins.

Bottom line: it can’t be understated that this not only a unique controller, it’s a controller you’d have no problems taking apart physically or in terms of software to change something. And that’s a very exciting thing, indeed.

Would I buy one? As far as DJ-style controllers go, absolutely — this would be on the top of my list.

Stay tuned for more specific hands-on, and let us know if you decide to pick one up. A big thanks to Matt and the Aurora team for sharing the project with me prior to launch and for responding to feedback!

All photos by Peter Kirn/(CC) Create Digital Media unless otherwise noted.

]]> http://createdigitalmusic.com/2008/08/27/hands-on-with-aurora-open-source-dj-control-surface-shipping-now/feed/ 32 http://createdigitalmusic.com/2008/08/26/preview-openstomp-open-source-effects-stompbox-us349/ http://createdigitalmusic.com/2008/08/26/preview-openstomp-open-source-effects-stompbox-us349/#comments Tue, 26 Aug 2008 15:51:47 +0000 Peter Kirn http://createdigitalmusic.com/?p=3868

Ever dreamed of being able to program your own DSP hardware as easily as you can connect custom effects on your computer? Earlier this summer, we saw the open source OpenStomp effects pedal. Then, information was scant and we hadn’t seen an actual unit. Now, the box is going into production for North America at US$349, available for purchase right now.

The magic inside is Parallax’s Propeller CPU core. If anything kick starts a DIY revolution for DSP hardware, this could be it. The software is Windows-only, but Mac users, could be a good reason to install Windows dual-boot; there’s a graphical interface for programming custom effects, vocoders, or whatever you like.

Effects so far, which come GPL3-licensed as open source patches:

• Tremolo
• Chorus
• Distortion
• Delay
• Tunstuff (Layered repeat loop)
• Test Tone
• Pong w/source

And it gets better: because of its use of the Propeller, video features are possible, too. (Yep, this could be a video stompbox — I’ll have to unleash our Create Digital Motion readers on that.)

I hope to have a chat with the creators so we can cover this in more detail; if you have questions you’d want answered, leave them in comments and stay tuned for a full-blown CDM feature.

OpenStomp Project Page + Details
Online Store

Previous round-up: Guitar Pedals Go DIY, Open Source

Via MusicRadar.com and several of you who sent this in! (Okay, stop with the awesomeness, already! We’re going to have to run like a dozen stories today. I need to eventually get out of the house!)

]]> http://createdigitalmusic.com/2008/08/26/preview-openstomp-open-source-effects-stompbox-us349/feed/ 28