Cycling '74

At Expo '74 in Brooklyn this year, Max users exhibited their work. Controllers are featured in the first video of the Science Fair series.

Peter Nyboer, Randy Jones, Nick Rothwell, and Jeff Snyder share their commercially available controllers that work with Max.  Included in this video are Livid Instruments controllers, Monome/Arc, the Soundplane, and the Manta

Controllers - Science Fair @ Expo '74 2011 - Brooklyn, NY

At the 2011 Expo '74, some Max users exhibited their controller work.

science-fair-projects-part-1

Science Fair Projects, Part 1

jpbellona

Korgnano is a software implementation of the Korg nanoKontrol USB controller. The object connects your hardware nanoKontrol to Max and automatically ports the data to korgnano.inputmenu objects, or specially named receive objects that you can create yourself. (e.g. receive scene1_ch9_btn2).  This was built as a Max package, and the folder should be installed in your packages directory.


korg-nanokontrol-max-package

Korg nanoKontrol Max Package

Andrew Benson

Max is all about making connections.  The Making Connections series of tutorials will introduce you to new connections you can make between MaxMSP and the outside world. This tutorial, the first in the series, will discuss the use of HID devices such as USB game controllers as gestural interfaces for your Max patches.

Since MaxMSP 4.5, the hi object has been included in the standard set of Max objects. This object allows you to get access to the stream of data coming from HID devices like USB joysticks. Using this object, we're going to look at using these extremely low-cost devices to provide gestural control of a Max patch. Once we have introduced the basics of making that connection, we'll also look into making some minor alterations to the hardware of your joystick for a more expanded use.

To follow along with this tutorial, you will want to find a USB game controller with a couple of analog controls. These are usually pretty inexpensive (less than $20 US) and can be found at any computer store. I personally prefer the ones with two small analog joysticks for your thumbs.

Download the Max 4.6 legacy patches and the updated Max 5 patches used in the tutorial.

Before you dig out your Joystick, let's have a look at what HID is.  The Human Interface Device(HID) class is a subset of the USB protocol specifically geared toward gadgets that provide some sort of interaction between humans and computers. The most common of these devices are keyboards, mice, and of course gaming controllers. When you plug a compliant device into your USB port, it will send a bunch of information to the OS about itself, like how many buttons or knobs it has and what range of data to expect. Because HID products can describe themselves to the OS so well, there is no need for manufacturers to cobble together device drivers and we don't need to search all over the internet to find them. Everybody is happy, except for the poor guy who has to write those HID Descriptors.

Ok, so now would be a good time to plug that Joystick into your computer. Once you've got your device plugged in, go ahead and start up MaxMSP and open the first included patch, 1.SimpleHInput.  This patch demonstrates the most simple way to get HID data into Max.

The first thing you will want to do is click the "menu" message.  This will fill your umenu with a list of available HID devices attached to your computer. If you are on a Mac, don't be surprised to see your keyboard and mouse listed here (sorry, Windows users, the OS keeps those things to itself). Since we are most interested in the Joystick, select it from the umenu to tell hi to focus on it. If you start moving the analog sticks and pushing buttons, nothing happens, right? This is because we need to tell hi to start polling the device. There are two ways to do this. The first way is to send it a "poll n" message, giving it an interval in milliseconds. This uses an internal timing provided by the object. The other way would be to leave polling turned off and supply a source of bangs such as a metro. Once we get this running, you should see a stream of numbers in the two number boxes below as you press and move the controls on your device.

So now that you've got the object spitting out pairs of numbers, you'll probably need to harness those numbers in a way that makes some sense. Luckily, there is some logic to the way that HID reports are sent to your machine. For each control on the device, there is an index number. This is the first number in the list that comes out of hi. The second number that comes out is the value of that control. For example, an analog joystick will usually have two index numbers associated with it (x and y), and a value range of around 0-255 for each (more if you are lucky enough to have a 10-bit precision device).

With the knowledge that we are looking at pairs of numbers with the format {index value}, we can find a way to divide up this data in a sensible way. By using a route object after the hi, we can send each controller index to a different outlet.  Because route strips the first element (index) of the list, each output will be the value of the associated control.

Using this information, we can create a simple control input for our patch, as shown in the next patch, 2.MakingSound. In order to make this patch work, you will first need to figure out the index numbers of a couple of controls. Try moving one of the analog sticks of your device. You will probably see two different index numbers coming out. Use these numbers to route the analog-x and analog-y signals to our sound-making subpatch. If the numbers are changing too quickly, have a look in the Max window at the printed data stream.

Now we will need to choose a button to use as our sound trigger. Pick whichever button you like and press it a few times. This will give you the index (remember that is the first number) of your button. Once you have changed the numbers in route and turned on the DSP, you should hear some sound when you hold down your trigger button. Now try moving the analog stick while holding it down...

In this patch, I am doing two things that are going to be vital whenever dealing with analog data - scaling and smoothing the data stream. If you look inside the p scaling subpatch, you will see that we are using zmap to scale the data to a usable range.  The data is then converted to a signal using sig~ and smoothed using slide~. This prevents sudden transitions in the audio, which can cause clicks and pops in the output. The output of this patch is then sent to the simpleFM subpatch, which should be familiar to everyone who has used MSP.

Now that you have learned how to assign individual controls from your joystick, you can connect these values to control virtually any parameter in MaxMSP or Jitter. Try creating filter sweeps using the lores~ object or changing the delay and feedback of a tapin~ tapout~ network using your analog joystick.  If you are using Jitter, you can assign the the analog stick values to a jit.xfade or other compositing object to create a video mixing system complete with clip triggering and control over different video parameters. With a little scaling or remapping of the values, you can create some very interesting controls for your patch.

Disclaimer: This section of the tutorial assumes basic familiarity with electronics and the use of soldering/desoldering tools. Cycling '74 assumes no responsiblity for damages to your gaming controller or any other device in following this tutorial.

Once you get the hang of it, connecting a joystick to control your patch will seem like no sweat at all, and you might start looking for another challenge. In this next section we will look at pulling the lid off of one of these devices and making a couple of simple alterations. The simplicity of a joystick's electronics make it a very affordable interface for connecting a few switches and knobs.

The first step to altering a joystick is to get the darn thing open. Most joysticks are simply screwed together on the back, so all you need to do is hunt down all the screws and unscrew them. There is usually one or two hiding under a sticker, so you'll want to check there as well.

The easiest thing to connect to your joystick circuit will be a switch of any sort. There are two ways you can accomplish this. The first way would be to solder the lead of your switch directly to the button contacts on the circuit board.

To demonstrate, we will solder in a mini toggle switch to replace one of the buttons of the joystick. To do this, we first attach a pair of wire leads to the switch. We then solder each wire from the switch to one half of the button contacts on the circuit board. Sometimes using a fine-grit sandpaper to clean the surface of the contacts will help the solder to bond better. Once you have soldered both leads in place, you will now have a classy switch to turn your patch off!

Depending on the joystick, this might be difficult to do, so often it is a bit cleaner to follow the traces on the circuit back to the little solder points that connect the traces to the chip. Soldering your leads to these points will usually be your best bet for the integrity of connection.

Switches are fun and very useful, but the analog controls are where a lot of the fun lies. If you look at the analog joystick elements, you may notice that each analog stick is really just two linear potentiometers connected to the circuit board. This means that any resistive sensor that has an appropriate range could easily take their place. However, before you can start connecting your flex sensors, you will need to first remove the joystick elements from the board. To do this, you will need a soldering iron and a desoldering tool (I personally prefer the bulb-type ones) to remove the solder that connects the joystick pots to the circuit. You will need to thoroughly desolder all of these points so that the joystick element will come off without too much trouble.

Once you've removed the joystick element, you can connect any variable resistance component in its place (e.g. photoresistor or flex sensor). Simply connect it the same way that the potentiometer was set up. For sensors that only have two leads, you will want to create a voltage divider by running a resistor between the sensor output and ground. You will probably want components that match the range of the joystick pots in resistance(~0-100k). Once you have connected the sensor you will be using, go ahead and start up MaxMSP and start playing.

Okay, so maybe it's not the easiest thing you've ever done, but it certainly beats designing a hardware controller from scratch. Which brings us to our final section...

Now that you know how to connect a USB joystick to MaxMSP, you might start hunting around for other devices that use the HID protocol. For all you brave DIY types, I recommend having a look at these projects that implement HID using commonly used microcontrollers:

Dan Overholt's CREATE USB Interface (PIC)

If you are interested in learning more about the HID protocol, check out the HID page at USB.org.

You can also take full advantage of the fascinating work being done by the gaming industry to provide more interesting controllers such as the floor-pads used for dancing games. All you need is the proper adaptors and a little knowledge and you can make the connection.

Max is all about making connections. The Making Connections series of tutorials will introduce you to new connections you can make between MaxMSP and the outside world. This tutorial, the first in the series, will discuss the use of HID devices such as USB game controllers as gestural interfaces for your Max patches. 

making-connections-connecting-a-joystick-to-maxmspjitter

Making Connections: Connecting a Joystick to MaxMSP/Jitter

Guillaume Evrard

OSCKAR is a tool that allows you to quickly use data coming from various hardware devices and network (HI, MIDI, Wacom, Keyboard, OSC, other messages) inside your own patches. It's developed for La Grande Fabrique, Dieppe, France.

OSCKAR generate an unique symbol referencing each incoming data. This unique symbol is OSC formatted (but not used as OSC yet).

examples :/MPK_Mini/1/ctl/1 would be control 1 on channel 1 of my Akai MPK Mini./MPK_Mini/1/notes would provide a list [pitch velocity] from channel 1 of the MPK Mini.

OSCKAR can also generate new data, re-use them in virtual devices, and share them over the network with other OSCKARs.

then, OSCKAR provide an virtual device builder, this allows you to aggregate data from different controllers to build your own virtual device. When building a virtual device you can choose as many data as you want, define scale and smooth settings for each of them, and rename them to have a human readable list of controls.

note : you can't use twice the same control in a virtual device, but you can use the same control in different virtual devices, with different scale and smooth settings.

3 - OK, I have built my virtual device, how do i use it ?

Once you're done building your device, just use the [osk.r] abstraction to access data from your patches. See the help file of osk.r for a complete description, or just double-click it to easily map a data.

OSCKAR comes with a template "instrument" (it's a patch OSCKAR can communicate with).

4 - Hey I've developed many instruments using your great tool. But it's a pain to activate/deactivate them !

No problemo ! OSCKAR has been designed to help you switching instruments on-the-fly !

With what I called "scenes" you can build an instruments bank, navigate inside your bank, and choose to activate/deactivate what you want. And these operations can be mapped on controls coming from your devices ! No need to touch your computer when playing live !

- OSCKAR is still under high development and the specifications are subject to change, but I'd be glad to have some feedback from some maxers at this point.
- A more complete user guide should be written within some weeks.
- Virtual devices are NOT cross-platform.


osckar

OSCKAR

The concept is simple: replace a few of the keys on a USB keypad with heavy duty footswitches.  Then use the select function in Max to direct these switches to control your patch.


Disclaimer: This tutorial assumes basic familiarity with electronics and the use of soldering tools. Cycling '74 assumes no responsibility for damages to your keypad or any other device in following this tutorial.


As a guitarist, I was looking for a simple hands-free controller for Max. Rather than buy an expensive pedalboard and MIDI interface, I decided to build a simple USB footswitch. It’s ridiculously easy to make and costs less than fifty bucks.

USB keypad (a keyboard can work too, but is slightly more difficult to wire up---more non-ASCII key functions)

momentary on switches (you will find these labeled “off-(on)”)

a box (I used a project box from the local electronics shop)

Download the Max 4.6 legacy patch and the updated Max 5 patch used in the tutorial.

First open the USB keypad. Each brand is designed a little differently, but most of them are held together with tiny screws. Some brands hide these under rubber feet or stickers. Don’t worry if you have to crack the plastic shell (it gets discarded), just be careful not to damage the circuit board itself.

Inside the enclosure, you will find a folded plastic sheet with wiring embedded in it. The keys press against this to complete a circuit. This sheet is connected to a terminal on the circuit board. Gently remove it from the terminal.

Trace the circuit on the plastic sheet to figure to see which two leads produce a desired character. Since this is a matrix, each lead is used for multiple characters so jumpers may be required. If you don’t particularly care which characters the buttons produce (we are, after all, going to be using select to filter this input data) you can skip this step. Just check each pair before you solder to make sure you don’t get results outside of the standard ASCII codes (i.e. num lock or “000”). If you want to specify the character output of each button, simply trace the circuit on the plastic sheet

Solder wires onto the terminal. There isn’t a lot of space, so you’ll probably want to use some fairly fine wire. To keep things neat, I used an old printer ribbon cable.

Drill holes in the box and mount the switches. Make sure to tighten them all the way. Then connect the wires, but don’t solder them just yet.

Run the test patch. As you press each button, its ASCII number will be displayed in the number box. Once you verify the ASCII numbers for each button, input these values as arguments to the select operator.  In this example patch I ran each outlet of the select operator to an oversized bang as a simple display.

Once you have verified that the desired characters are produced, solder wires to the buttons.

Essentially this is just a cheap and easy way to connect momentary switches to your computer via USB. This same principle can be used with other types of momentary switches---percussion triggers, tilt switches or even some types of light sensors. Non-momentary switches can be used too; they will output continuous streams of repeated keystrokes. Use the change operator if you want to make these switches behave like momentary switches.

This same footswitch could also be built using a wireless keypad.  How could this change the usability of the footswitch?

If you wire one of the switches to num lock, you can in effect double the number of keystrokes available to you while using the same number of switches. If you plan to do this, you may want to use a keypad that has an LED num lock indicator. If it is difficult to mount the circuit board in such a way that the LED is visible on the footswitch, consider replacing the LED with one with longer leads.

As a guitarist, I was looking for a simple hands-free controller for Max. Rather than buy an expensive pedalboard and MIDI interface, I decided to build a simple USB footswitch. It’s ridiculously easy to make and costs less than fifty bucks. Here is what you will need to do...

Search Results