Exams are finally over and I can spend much more time experimenting with controllers without any traces of guilt. The major highlight for this post will be my new Arcade Warrior controller, a shameless rip-off of the Midi Fighter Pro (thank you DJTT for being such a great source of inspiration), and the Teensy++ micro-controller board.

I will start off real quick with Teensy++, it’s a very nice and small AVR micro-controller, very similar to Arduino. In fact you can use the Arduino IDE and libraries to program Teensy, which is amazingly handy! But the reason I chose to try it was because of it’s MIDI Class Device support, something that Arduino can’t do. This means that it can act like any professional plug-and-play MIDI controller, no drivers, compatibility layers and virtual MIDI ports required!

Of course to test it out in practice, I had to build a new controller. And this one I wanted it to be a really fun to play and cool looking device, and what suits better than the old school arcade games that we all loved as kids. I wanted to build something as expressive as the Midi Fighter Pro, but throw couple of more extra controls in there and a Pac-Man era joystick. Also being able to use Midi Fighter’s already very developed Traktor mappings would save me tons of time and effort. Fortunately all the MIDI signals documentation and mappings are publicly available at DJ TechTools so it was very easy to implement.
Armed with ergonomically placed rapid fire arcade buttons, smooth professional audio gear potentiometers and the joystick controlling expressive gestures, it turned out to be a very nice and responsive controller.

PS: After a lot of questions about the wiring of the buttons I decided to update this post.
One of my goals when building this controller was to make things as simple as possible and use the least number of components. That’s one of the reason why I have included only 3 LEDs. The buttons and Joystick are wired in a very simple manner. All the ground pins (white cable in photo) are daisy chained together and end up on the ground pin of Teensy and all the colored wires are connected to one Digital Input pin on the Teensy, so no resistors required. In order to use this method, you have to enable the pull up resistor for each of the pins in your microcontroller, and this is done by setting the pin mode to pinMode(buttons[i],INPUT_PULLUP); during initialization.
Also note that if you use the pin 6, which is the one that has a LED on the Teensy, you have to set it to pinMode(6,OUTPUT); in order for it to function like the rest.
Finally, since now the buttons operate in active-low logic, this means that if the button is pressed it becomes LOW other wise its HIGH, you have to check for button presses like this if (buttonState[i]->read()==LOW)//is pressed

Also all the analog controls are routed through the breadboards and ribbon cables directly to one analog input on the Teensy.

Here is one simple diagram and a photo of my wiring. Hopefully this clarifies things.

Enjoy and keep your emails coming!

I haven’t made any posts in a while so I got a couple of updates to share with you. Before I begin with some of my latest developments, I would like to refer you to two people that inspired me very much with their work and ideas, Alex (fuzzywobble) and Dave (60works), check their websites, they are very passionate about building controllers and have a lot of well documented information.

Firstly, I decided to improve a little bit my Rotary Encoder device, since it was the one that got the least attention from me but deserved a lot of it since it was the device that started my controllerism journey. It basically consists of 4 rotary andcoders and encoder LED rings from MayhewLabs, heavily inspired by the monome ARC 4 but for now it runs only on MIDI. I had to rewrite the whole firmware and communication protocol from scratch in order to support “proper” encoder functionality and the ability to set the LED’s through MIDI messages. I also wanted them to work much or less like jog wheels in Traktor, so I had to correctly setup the CC messages. I figured out that whenever you turn the encoder right it has to send a CC 1 value and when left a CC 127 value. And use the 7Fh/01h encoder setting in Tractors mapping. So now, unlike I stated in my previous post I have the ability to scratch too I mapped some more effects to them and above is a little jam video I came up with. Also since an Arduino Uno can only support up to 2 rotary encoders, I had to do a little dirty trick wiring an mini pro board through SPI

After that I shifted my interest back on Ableton Live and its very restrictive mapping mode. Something had to be done, I couldn’t fully utilize my devices. After some research I discovered that there exists a very interesting folder called MIDI Remote Scripts with many python files. Those are the controllers you can choose from the drop down menu in settings. After some more reaserch I have found the golden resource for Ableton scripting, decompiled scripts and libraries revealed the whole API. It was a matter of poking around and I had a basic “launchpad” functionality. A magic red box moving around and launching clips. After some consideration of my workflow in Ableton Live I decided to re-size the box to only 4 chanels and use the other half of the grid as effect triggers. Lets see what comes out of that.. I will probably make a video of that sometime later on.

And my last adventures were participating in DJ TechTool’s Midi Figter 3D competition. Maybe I didn’t win a Midi Fighter (oh well I guess I could always build one myself ) but I was really surprised when that sloppy video got literally thousands of views in almost no time! So the fact that it raised interest and awareness is the best prize for me!

End of captain’s log.
Until next time! Peace!

After Native Instruments announced its new controller, Traktor Kontrol F1 (a very colorful grid controller (with some faders and knobs), designed for the new Remix sample decks in Traktor 2.5) and also heavily inspired by a local DJ friend of mine, I decided to make a mapping for my button pad.

The idea was to test/demonstrate the use of different colors on my device and see whether it was possible to fully operate Traktor with just one grid controller. I believe I covered all the major controls apart from scratching (sorry guys), I think it works best with prepared sets and hot-cues.

Traktor’s MIDI-mapping options are very powerful and flexible, really amazing job from Native Instruments there, BUT there is completely no automation for this very repetitive manual task. Basically you have to manually chose all the GUI elements, signal types and note values from drop-down boxes, no “click-n-press-key” mappings that are found in DAWs and you have to map everything twice, for input and output. It took me 4 freaking days to finish the mappings.

The device is split in half for Deck A and Deck B, so all the controls are mirrored on both sides. On the top there are FX controls, then Volumes and X Fader, Play and Cup buttons, all of the above are constant controls. Then I used modifiers to create “pages” or tabs for the rest of the things like tempo, loops, cues, EQ, and loading tracks. At first everything looks like a rainbow-puke, colorful mess, but actually everything is organized in a logical manner. I have prepared some diagrams to help you visualize how everything is layered.

So here are the constant controls.

Track progress and Tempo control pages.

Hot-Ques and Loops pages.

And finally the EQ page.

You can download my mappings from here.

I have a lot of updates on the project since last time, tons of changes made mostly on driver application. I discovered that one of the main sources of latency was the serial port class of Processing, so I decided to re-implement the driver in C#, since Max/MSP and Ableton Live are not running under Linux anyway.

Also this gave me the opportunity to implement monome applications compatibility and it works pretty much flawlessly with any Max patch I threw at it, tough I did not implement AutoConfig protocol so its limited to the monomeOSC version of applications that run with OSC extensions. Also further more, worked on reducing latency and read/write buffer bottlenecks with pleasing results, now I can finally enjoy mashing on mlrV

Also made some silly Processing sketches, like displaying 8×8 3bit image files on the pad.

Plus designed more plywood face plates for the pad and other devices.

This gives me the opportunity to introduce my new device [k]ontrolPad. This controller consists of 4 faders, 8 knobs, 8 buttons with LEDs, XYZ accelerometer and an infrared proximity sensor. But for now unfortunately only the buttons and LEDs seem to work properly. The rest of the analog values are quite unstable and must be normalized, also I have to figure out a way to send their values synchronously and only when it changes, instead of just sending a bunch of redundant data over the serial port, which by the way dead-locked my serial port in Linux..

And finally, since a lot of people asked me for, I have released the firmware and drivers, also some processing sketches. You can find everything on my Bazaar repository, just browse the code and you will find a zip/rar file to download. Or use the following direct links:
Driver
Firmware
Testing

And a bit older video just to demo it working with Live in MIDI mode.