After messing around with my own MIDI Fighter clone, I realized that although it had some very useful and expressive mappings for Traktor, its focus simply on the Drum Rack in Ableton Live is little bit… poor. That’s why I decided to create a little MIDI Script that would grant it some of the functionality that Launchpad or the APC has. More precisely Track, Clip, Device controls and of course keep the Drum Rack functionality.

For the purpose of developing and testing in hostile environments, where smuggling in a controller would be hard, I developed a simulation app in Processing, that would send the same MIDI values the MF Pro by simply using your computer keyboard. Also you can control the faders and knobs with the mouse. Simple, yet effective.
Download: github.com

Now back to the Script. It consist of 4 pages, somehow similar to the Modes on the Novation Launchpad.
Page 1: is the General control page and consists of tempo controls, global play, stop and record and the controls to move around the “red box”
Page 2: is the Track control page. Each row corresponds to one of the rows inside of the red box. And it consits of Track select, Mut, Arm and Solo.
Page 3: is the Clip control page, you have a 4×3 grid and the top row is the stop button for each track.
Page 4: is the drum rack pad. It plays the highlighted 4×4 grid in the drum rack.

Also the knobs and faders get automatically mapped to the first effect device of the selected track.

Here is a detailed diagram of all the controls:

Hopefully this script adds even more functionality to this great controller from DJ TechTools
Download: github.com or djtechtools.com

PS: thanks to gonecrazy3000 for pointing out that the preset buttons on the Beat Masher are arranged differently
so the pages would be like this:

preset button 1 =>page 3
preset button 2 =>page 1
preset button 3 =>page 4
preset button 4 =>page 2

Now go out, start a Fight and Loose. Peace!

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!

Greetings once again, the last few days I gave more emphasis on working on the [k]ontrolPad and realized that my previous video did not demonstrate much the original concept I had in mind. So here is one more little demonstration video and some pictures of the development process.

As I noted in my previous post, there is a lot of noise in the analog readings, I’m not really sure what is causing it but I managed to reduce that by lowering the resolution of the readings, anyway the MIDI protocol does not support 10-bit numbers though some spikes occasionally do get through. I tried taking the average of the previous few readings but that definitely slowed things to an unusable level, although it did produce amazingly smooth graphs. Also another way is implementing a LP filter using capacitors which I didn’t test either.

The communication protocol is quite similar as before, button presses send b01 or b00 (where first digit denotes the button number and second the state), similarly the device recieves l11 or l10 for setting LEDs and r requesting for the analog values which are then sent back as one string separated by commas v64,101,0,0,15,30,50,0,127,0,0,0,13,40,45,36,.

The driver application then listens for changes in those values and sends them down to the virtual MIDI port. Unfortunately there are some bottlenecks with the set led commands. Which are most likely due to too many analog values coming through.

Also for the accelerometer and distance sensor I’ve set an option to choose which kind of MIDI command to send, the default CC passing the value or a NoteOn if the values pass a certain threshold so those can be used as a switch as well. This is demonstrated in the video above.

And finally designed a plywood jigsaw case to hold everything together.