#1

If this thread already exists, please link me up!

I’m a midi devotee (username makes that obvious I guess) and I’ve used about every style of controller out there on the consumer market. I’m hitting a point, though, where it might be worth investing the time to learn to make my own midi controller.

I’m sensing that I’ll need to go beyond the basic instructables I’ve found, which mostly suggest the pots-and-arcade-buttons-in-a-box kinda designs. I’m hoping for something just a tiny bit more ambitious, with velocity sensitive, silky drum pads (pads that feel like the QuNeo or the Maschine would be a dream) and a spring-loaded potentiometer that I move with my thumb (it’s a long story: basically I’m trying to design a thing that translates my nervous habit of one handed drumming into something that approximates a small drum kit). Given those ambitions, I’m anticipating that this is going to be a protracted learning experience.

I have the most scant of programming experience (like, I vaguely remember how to hand code html markup from my 1998 geocities days) and I have yet to totally wrap my head around navigating github. In terms of basic hardware tinkering, I have a soldering iron and maybe about 20 hours using it, max. But I can get around enough to, for instance, solder up my own guitar cables.

For those of you who have gone down this road, what are the best sources you’ve found for figuring out arduino (which I’m guessing is what I’ll probably use, right?), figuring out the best way to source parts in small batches, figuring out whether or not FSRs are the way to go for drum pads, etc.?

Thanks in advance, wonderful Lines community!

1 Like
#2

For DIY MIDI controllers, I greatly like the Teensy - you can write in the Arduino IDE for it, it behaves out-of-the-box as a USB HID device, and there’s good sample code available. I’ve made some foot controllers with it. It has lots of digital pins and enough analog ins for most purposes.

Sourcing parts in small batches: well, go to people who’ll sell them in small batches - in the US, Sparkfun/Adafruit/Small Bear, for instance. Beyond them, Digikey/Mouser/Farnell and so forth, though be wary of minimum quantities.

For spring loaded pots, remember that the “spring-loaded” element can be totally separate to the actual pot. For instance, a pitch bend wheel might be a spring-loaded lever (mechanical engineering) promptly connected to a fairly regular potentiometer. Or it could be an all-in-one thing. But you have flexibility there.

Pads are complex, though again, you’re perhaps looking to go down a route of separating out pad design/material from the way the pad is detected. I’ve used FSRs that are very sensitive, but also very, very expensive; the trick will be finding the sweet spot of price / implementation / feel.

1 Like
#3

Yeah, Teensy seems to be the popular choice for DIY MIDI.

I only built one mini FSR controller way back at the start of grad school, but it was insanely easy. I used an Arduino Uno back then, and it was pretty plug-and-play. The hardest part would likely be building the case, honestly. It was literally two of these plugged into an Arduino:


Back then, I had to use PD to convert the Arduino messages to MIDI. Nowadays, the Teensy (and some of the Arduinos) can do MIDI-over-USB out of the box.

A really good spring-loaded option is the Playstation joystick: https://www.sparkfun.com/products/9032
https://www.sparkfun.com/products/9110
It has XY control and a button. This is what @TomWhitwell used on his AxoControl project:
http://musicthing.co.uk/modular/?p=1375

Speaking of which, the Axoloti is another great way to go. It’s fairly cheap, and it comes with a lot of the stuff that you would typically want for audio and MIDI (USB over MIDI, 5-pin ports, etc.). On top of that, there are a lot of modules in the User Library that can be used to create very complex MIDI behavior, like holding a button to activate an arpeggiator or trigger pattern.
http://www.axoloti.com/
(Plus, you could upload a patch that keeps all of the MIDI functionality while simultaneously generating audio on the outputs…)

You don’t necessarily need to use Tom’s AxoControl, either. You could build your own control scheme and enclosure. The great thing is that Tom’s project is totally open source, so it at least gives you a map.

1 Like
#4

+1 for using Teensy. I’ve used it for a bunch of projects now, including 2 MIDI controllers…

http://www.cutlasses.co.uk/uncategorized/midi-mustard/
http://www.cutlasses.co.uk/uncategorised/midi-pedal-complete/

I found this page really helpful when starting out too http://little-scale.blogspot.co.uk/2012/10/a-very-simple-diy-usb-midi-controller.html

Good luck with your build!

#5

Thanks for these links! I love hearing from people who were vary much beginners when they got into this. The pics are great. I might hit you up as I move forward!

1 Like
#6

Michael, you’re the busiest dude in the game, I swear! Thanks again

1 Like
#7

Aside from hardware, you’ll also need programming skills. The two books I read to begin with were Accelerated C++ by Koenig and Moo, as well as The AVR Microcontroller and Embedded Systems by Mazidi et al. I really enjoyed the hands on approach of the former book (write as much code as possible while reading the book and make it run if you can). The latter book includes a lot of general information about computers, and mostly uses AVR assembly language for the examples. I actually found this extremely useful, as it really solidified my understanding of how computers work and what they are capable of doing. Even as a beginner (maybe especially as a beginner) I think learning a little bit about assembly language is worth while, even if you never actually write any of it. A book on ARM might be more useful than one on AVR though; ARM is a lot more powerful, and is what’s used in e.g. more modern Teensy boards, Axoloti, Raspberry Pi, many Mutable Instruments modules, and surely many other examples.

After reading these books and making some simple and some not so simple projects I started reading the source code for the Arduino libraries, which I highly recommend doing at some point of you use Arduino a lot.

+1 for Teensy; the built in USB MIDI capabilities are stupendous for making a DIY MIDI controller, and the documentation on the Teensy website is pretty good.

#8

That’s all quite helpful and I’ll definitely take note of those books as good resources for coming to terms with c++

How much of that is really needed to make a midi controller with teensy, though?

I’m all for learning things the “hard way”: if someone asked me how I learned to learn produce electronic music, I’d tell them that it’s been a long journey of listening to everything I could get my hands on, brushing up on my music theory, practicing drumming, learning midi, muddling through a bit of reaktor, and getting to know Ableton like it’s my life partner, more or less.

But to get them started and fuel their excitement, I could also direct them to a handful of iOS apps and, with some creativity, they could make something pretty decent without learning how to, say, do crazy midi routings in Ableton.

So while I support the deep dive into c++ and assembly language, can I get some serviceable results by struggling through the Teensy documentation, cribbing some code, and trial and error?

In my day job i’m working on a PhD, so while re-teaching myself recursion and while loops would be a great way to procrastinate the thesis, I’m not sure I want to open up the procrastination can THAT widely just to make a custom drum controller…

#9


A lot of projects here:
http://www.instructables.com/howto/midi/

Yes. The Instructable tutorials feature most of the code that you need, which consists of polling the various pot/sensor inputs.

More advanced topics…
-Keeping track of endless potentiometers. You’ll receive deltas instead of direct values.
-Filtering noise from analog inputs. This is typically not much of a problem with low-resolution MIDI controllers, though.
-Notes instead of CC values. With notes, you have to make sure that Note On and Note Off messages are kept track of, or else you’ll get hanging notes.
-Bluetooth/wireless performance (if desired)

#10

Hey @midilifestyle! If you’ve never done much programming before, a good place to start to start is Learn Python the Hard Way (https://learnpythonthehardway.org). There’s other getting started for a total newbie type of e-books out there, just Google: Learn [insert language here] the Hard Way. I don’t know much Python myself, but developers I know seem to think it’s a good language. It’s supposedly simple to pick up too. Arduino uses some kind of abstraction of C/C++, and there is a Learn C the Hard Way out there if you want as well.

Basically what I’m getting at is these types of e-books / guides are good for beginners because they make no assumptions about your skillset. This can be annoying for anyone with coding experience, because they go as far as walking you through every banal activity, like having you download and install a text editor.

Good luck! I tried learning to build a MIDI foot controller for my guitar once, but lost interest in that project: http://blog.welense.com/1075842

#11

Yes.

Teensy/*duino code isn’t C++, it’s at best a subset of common old C. You don’t need to learn assembly right now. These things will still be there for you later if you’re interested. But I think at a sensitive time in anyone’s experience of programming, recommending assembler is… risky, to say the least. You might find that if you start by thinking-through-playing, you’ll join up with the other train of thought in the middle.

For now, you’re fine. Depending on how far you go, you might need to return to these.

#12

I like to call it “test driven development” :slight_smile:

Starting with some assembly worked well for me, but I can definitely understand why that might not be the case for everyone. If you prefer your trial by a different kind of fire (I like mine particularly hot), you can definitely dive in and achieve good results very quickly with Teensy. Most of what you might need to know to make many kinds of MIDI controllers is contained in the first two example files located at File Menu>Examples>Teensy>USB MIDI in the Arduino IDE after you install the Teensy add on.

If you’re specifically interested in making a drum controller, you might be interested in the open source firmware for the Linnstrument. The velocity calculation is done in ls_touchInfo.ino calcVelocity(), and the author explains the algorithm in plain language in the latest (bottom) post on this topic on the Linn Design forum.

#13

on the flipside, if you want to get some things up and running really quick you should check out this library: http://tomashg.com/?p=854

It has been a while since I messed around with Teensys, but I got a lot of mileage out of this in terms of getting things running asap.