I am charged with setting up the 3D plotter and vinyl sign cutter (the laser cutter is already set-up), then developing a written and video tutorial and a few sample projects for each of these devices. I already know how to use the laser cutter, so that tutorial has been coming along nicely.
Next week I’ll shift my focus to the 3D plotter. I will have a lot of work ahead of me – I’ll have to learn how to set-up the machine, and then run several jobs on it to get a good sense of how it works so that I can develop the tutorials. Lastly, I’ll do the same for the vinyl sign cutter.
AMUP air is a DJ MIDI controller for Ableton Live. The way in which the switches and sensors from this controller are mapped to functionality within Live is a core element of the user experience. This mapping must feel intuitive for this device to deliver on my vision.
Therefore, before finalizing the Arduino sketches for each AMUP component, and in preparation for developing the Live MIDI script, I needed to think through the functionality that should be assigned to each and every switch and button (all 108 of them, including the monome).
There were several learnings from my experiences using the original version of AMUP that I wanted to address in this prototype. First off, I wanted to add direct feedback on the air panel to support the control of volume using the proximity sensor. Secondly, I realized that it was best to use a single scene selection controller for all tracks since this is not a track-specific function. Lastly, it became clear that I needed to have access to transport controls such as coarse and fine tempo, tempo nudge, and clip launch quantization.
I also wanted to expand the functionality provided by AMUP in several ways. First off, I added three potentiometers to support direct control of Live parameters such as the effects send for each track/channel. Next, I integrated support for multi-modal functionality using button pads with RGB leds. This enables using the potentiometers to control multiple different sets of parameters within Live, such as mixer and device settings associated to specific channel. Lastly, I integrated a monome into my AMUP set-up to enable me to control clip launch, track monitor and stop controls, and more.
Here is an overview of the functionality controlled by each component within the AMUP set-up. In the next couple of days I will create a post with the full MIDI map for this device.
The main console was designed to control several transport functions from Live, including clip launch quantization and tempo controls. It also features controls for the assignment of control pads one and two to one of the four tracks in Live.
The button pad was designed to control various parameters associated to the mixer, tracks, devices and clip loops. This component supports multi-modal functionality that enables the potentiometers to toggle between controlling mixer-related parameters such as eq and effects send, and device-related parameters that vary by device.
The air panel uses a proximity sensor to control Mixer functions such as the volume of an assigned track. In the future this sensor may also feature multi-modal functionality similar to the potentiometer on the button pad, so that it can control device functions.
The monome is the latest addition to the AMUP set-up. It is used to handle several transport functions, such as scene and track scrolling; and mixer functions, such as track monitoring. It also enables direct control of clips within a moveable 4 x 7 clip slot matrix.
To create AMUP air I redesigned the circuit from scratch with three goals in mind. I wanted to fix all the bugs from the initial design to make the system reliable enough for live performance; to add support for functionality such as direct feedback on the device itself; and, to make the system more modular and extensible, so that I could change the components in a set-up, and even create new ones.
Before getting into the schematics of each individual components, I am going to provide an overview of the architecture for the entire circuit – this is definitely the first time I have been able to honestly use the word architecture to describe one of my circuits. Here is an image of the circuit architecture for the AMUP air:
In order to make the system more modular and expandable I gave each component its own Arduino. Based on size and price considerations I decided to use a set of bootloaded atmega328 microprocessors rather than full-featured Arduino protoboards, except for the main console that features an ArduinoMega 2560. It’s easy to make your own Arduino protoboard, this tutorial from the Arduino website shows how.
The process of learning how to bootload the chips was rather painful until I figured out how to solve the issue that was driving me crazy. Now I can set-up a personal bootloading factory. Soon I will create an arduino bootloading tutorial with tips gained from my personal suffering (at which point I will add a link here).
In order for this new approach to work I had to find a way to connect the three existing AMUP air components: the main console, button pads, and air sensors. I decided to connect the air sensors to the button pads using serial, since only one air sensor is connected to each button pad. For the connection between the button pads to the main console I have chosen i2c because it enables multiple components to be connected using the same two pins on the Arduino.
For comparison, above is a diagram that illustrates the circuit architecture of the AMUP classic. As you can see, the classic used a single ArduinoMega2560, which was directly connected to all the components using four 16-channel multiplexers.
To enable AMUP air to provide direct feedback I decided to use rgb leds – the button panel features 8 rgb leds, while the air sensor panel features 10 rgb leds. To drive such a large number of rgb leds from a single Arduino you can either create an led matrix, use a demultiplexer, or use an led driver. I decided to go with the last approach because it provides the most control, and saves processing power on the Arduino to do other stuff.
After testing several different components I came across Texas Instrument’s tlc5940. These led drivers are awesome. Each one provides 16 dimmable pins and connects to Arduinos using a daisy chainable serial interface. An arduino library exists that makes it really easy to integrate these chips into your code. I bought a bunch of extra ones to play around with on other projects. Here is a link to more information about using the tlc5940 with Arduinos.
In order to design circuit boards for the button panel and air (prox) panel, I needed to create a full schematics of each circuit. Creating a full schematic using application such as Eagle CAD or Fritzing is a really great way to plan out your circuit. In the past I had used hand-scribbled schematics, which are fine for simple projects, but for big projects these software packages make a big difference.
If you are interested in learning how to use Eagle CAD to build schematics for your own project I strong recommend Sparkfun’s Eagle schematic tutorial. This tutorial guided my own schematic design work for this project.
Here is a slide show with the schematics for the button panel and air sensor panel. Note that multiple schematics refer to each one of these components.
The process for developing the final schematics, which were used as the basis for the printed circuit boards, took several rounds of prototyping, testing and revisions. It is important to test your entire schematic before you finalize the design of your pcb; and even so, you will likely discover issues with your first draft. I have already done one round of revisions to the pcbs and the button board still contains a few minor issues.
Printed Circuit Boards
My decision to integrate printed circuit boards into this project was driven by several considerations. I wanted to make the circuit more robust and clean by reducing the use of wires; I wanted to minimize the footprint of the circuit; and, I wanted to continue to develop my pcb design skills.
I have fabricated two different sets of protoboards for AMUP air. The two boards pictured above are from the first set. Before ordering the second set of boards I made sure to set-up the initial version, making all of required fixes to get them working properly. To get both boards working I had to scratch off a few short circuits and use wire to connect a few components that were left stranded.
Once the first prototypes were working, I updated the pcb design files and sent the second prototypes out for production. I haven’t yet assembled the new prototypes but I already know that some of the issues from the first boards have persisted.
I have limited experience working with printed circuit boards. Before AMUP air, I had only designed and fabricated a circuit board for my Emote project. To help me develop, fabricate and test my pcbs I relied on guidance from Sparkfun’s Eagle CAD pcb design tutorials. These tutorials were invaluable.
I also used Sparkfun’s SMD soldering tutorials to help me learn how to solder small surface-mounted components onto the PCB. These tutorials helped me to finally learn to use a desoldering braid to remove jumpers from existing solder joints.
Over the past several weeks I have gone completely silent. Though ITP has finished, this is not a sign of me taking time off. Rather this is a result of a sprint to finish prototype 2.0 of my AMUP project (dubbed AMUP air) before a party at Lauren’s school, at which I was scheduled to dj. This party came and went last week. Unfortunately, I was not able to finish the prototype on time – I am actually still working on it.
In this post I will provide a brief overview of the main updates, along with a sneak peek at how it is all coming together. To refresh your memory about AMUP, here is a link to previous journal entries that describe the original vision for this project and the development process for the first prototype.
The first version of this project had not come close to delivering on my vision, though it did provide me with inspiration to continue my pursuit. It’s main flaws included buggy circuitry, which made it unreliable for live performances, and a lack of feedback on the device itself, which made it difficult to control certain parameters without looking at the screen. The physical design of the device itself had an interesting feel clunky as well.
For version 2.0 I wanted to fix all the issues mentioned above as well as making numerous other improvements such as adding new buttons and switches; making the hardware more extensible and robust; developing a more modular software architecture for the Arduino; and integrating deeper into Live’s functionality using the python API.
Here is a brief description of how I have attacked all of these updates over the past month:
Fixed bugs in circuitry by rebuilding the schematic from the bottom up. To improve reliability I designed a printed circuit boards for the button pad and air sensor components, and integrated new components such as LED drivers, multiplexers and capacitors.
Added support for direct feedback on the physical device itself using RGB led lights. On the air sensor, these leds provide direct feedback regarding channel volume, while on the button pad they enable the buttons to support multiple states.
Reconfigured the switches, buttons and potentiometers in response to learnings from first prototype. Added inputs to control quantization, tempo, effects send, along with support for multi state functionality.
Designed a more modular and extensible architecture for the hardware. Each button and air sensor panel combination functions as a standalone unit that can connect to the main console. Theoretically I can connect over one hundred button pad/air sensor components to the main console; though due to latency considerations the limit is much lower (I assume around 4 or 5).
Working on enabling deeper integration between AMUP and Live by using Live’s Remote MIDI scripts. These python scripts enable you to access a wide range of Live’s functionality that is otherwise unavailable.
Over the coming weeks I will provide more in-depth overviews about how I’ve addressed all of the areas above. I will also share several tutorials related to skills I had to acquire while working on this project:
Bootloading AVR chips with Arduino
Writing an Ableton MIDI Remote Scripts in python
To support this project I’ve developed a set of related libraries that handle digital and analog switches by providing services such as: smoothing data from analog switches; debouncing input from digital switch; making it easy to set-up and read rotary encoders; and supporting multi-state RGB buttons. All of the components in this library adhere to the same design pattern, which will hopefully make then easier to use. I will write-up some additional documentation in a future post, but for now you can find the library on my github page here.