Arduinome dual panel faceplate design

These aluminum panels are each 5 mm thick which leaves about 2 mm of the SparkFun buttons exposed. My initial test of the faceplate has resulted in a lot of the buttons getting stuck, though most of them not enough to actually make contact. I think that with some time put into smoothing out the button holes and edges that this will provide great button mashing action.

Here is another view:

Arduinome with aluminum faceplate

and another:

Arduinome money shot

I just can’t get enough glory shots of blinky button grids!

Arduinome parts

Arduinome is a clone of the open source monome 40h which uses an arduino microcontroller.

Wikipedia says, “The monome is an eight-by-eight grid of backlit buttons which connects to a computer using a USB cable and the Open Sound Control (OSC) protocol. Originally developed as an open ended performance interface for electronic music, its developers have said “The wonderful thing about this device is that it doesn’t do anything really.” As a result, developers have begun to use the monome as an interface for other types of software, from text displays to games.”

Here is some video of vimeo user ro using a monome 256 running mlr and a monome 40h running vu_spec (part of the monome_base), which is an 8 band spectral display.

I am following the build instructions posted by Curious Inventor. I started soldering all the LEDs and diodes last night. In an hour and a half I got through all the LEDs and a quarter of the diodes. (there are 64 LEDs and 64 diodes) I think I should be able to finish the diodes tonight and get started on the unsped arduino shield.

I am waiting to hear back from machinecollective.org about when a case will be available to ship. The sooner the better. I can’t wait to use those blinky lights and soft buttons to mash things up with MaxMSP, Ableton Live and Max for Live.

Arduino IDE

From the arduino.cc website:

“The open-source Arduino environment makes it easy to write code and upload it to the i/o board. It runs on Windows, Mac OS X, and Linux. The environment is written in Java and based on Processing, avr-gcc, and other open source software.”

Arduino 0017 Release Notes:

0017 - 2009.07.25

[documentation / examples]
* Many new and revised examples from Tom Igoe.

[core / libraries]
* Updated LiquidCrystal library by Limor Fried.  See reference for details.
* Updated Firmata library to version 2.1 (rev. 25).
* Replaced the Servo library with one (MegaServo) by Michael Margolis.
  Supports up to 12 servos on most Arduino boards and 48 on the Mega.
* Improving the accuracy of the baud rate calculations for serial
  communication (fixing double-speed problems on 8 MHz Arduino boards).
  Thanks to gabebear.

[environment]
* Synchronized with the Processing 1.0.3 code base (rev. 5503), bringing
  many improvements (listed below).
* New icons and about image by Thomas Glaser (envis precisely).
* Support for multiple sketch windows.
* The serial monitor now has its own window.
* Comment / Uncomment menu item (in Edit) and keyboard shortcut.
* Increase and Decrease Indent menu items (in Edit) and keyboard shortcuts.
* Support for third-party libraries in the SKETCHBOOK/libraries folder.
* Libraries are now compiled with the sketch, eliminating the delay when
  switching boards and the need to delete .o files when changing library
  source code.
* Arduino now comes as an app file (in a dmg) on the Mac.
* Adding the Arduino Nano w/ ATmega328 to the Tools > Board menu.

I am happy to announce that my Pachube feed organizer/viewer application PachubeMon is now available as a free download on the App Store. It was also announced on the Pachube blog on Monday.

PachubeMon iPhone app

Pachube is a web service available at pachube.com that enables you to connect, tag and share real time sensor data from objects, devices, buildings and environments around the world.

PachubeMon is a utility app for the iPhone that lets you manage and view your Pachube feeds all in one place. The main page allows you to add and remove feeds. By selecting a feed from the list you can view it. You can find feed IDs on the Pachube website here.

For a fascinating deeper look at Pachube and the concepts around it, check out the amazing article and interview here.

I have already sent off a request for an invitation to the beta version and am watching my inbox with excitement. I can’t wait to use an arduino to start logging some data to share online. I would love to track the sun light in my garden or the energy usage in my house or use Pachube as part of a home automation system. Perhaps I will be able to monitor how much time I spend making music versus downsurfing on the interweb!

There is already a convenient way to follow peoples Pachube feeds on your iPhone but it might also be interesting to explore the API and create a handy Pachube iPhone app of my own.

A lone pushbutton switch

Before setting out to debounce my pushbuttons I did some searching on Google and discovered an excellent article on debouncing called simply, A Guide To Debouncing. It covers multiple techniques for both hardware and software debouncing.

After reading the article, I decided to go with a software counting algorithm. I did some more research but I wasn’t happy with the examples that I found. All of them involved debouncing a single switch. I wanted to debounce an entire port of switches. To do this you could just repeat the debouncing code for each switch but I decided to write a single piece of code to handle an entire port.

Below is my solution using PORTB on an Arduino. PORTB is a six pin port. This could easily be ported to be used on any AVR microcontroller or indeed any other microcontroller that can be programmed in C.

My Arduino NG

All the pushbuttons in my example are active high with pull down resistors. The code could easily be adapted for active low. (Note that my prototype actually only has two buttons connected to it. I set up wires with pull downs to act as switches for the remaining pins)

First we define the number of switches on our port (in this case six), then the debounce depth. Debounce depth is the number of consecutive times that a switch must be read to have a certain value (HIGH or LOW, 1 or 0) before a press of that switch is validated.

#define numButtons 6
#define debounceDepth 10

Next we set up the variables we will need. The first one is used to read the PORTB value into. The second is to keep a memory of the last debounceDepth number of reads. The next keeps tabs on whether the pushbutton switch has been released after pressing. This variable provides a form of hysterisis so that we don’t get multiple toggles on one button press. The buttonPressFilter is a bitwise ANDed sum of all of the debounceDepth number of memories. The result in the buttonPressFilter is what determines if a pushbutton switch has been validly pressed.

char buttonRead;
char buttonMemory[debounceDepth] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
int buttonHasReleased[numButtons] = {true,true,true,true,true,true};
char buttonPressFilter = 0xFF;
int buttonState[numButtons] = {0,0,0,0,0,0};

So that is the end of initialization. Now onto the code that you would put in your loop. The buttonPressFilter is an 8-bit variable with each of the lower 6 bits representing the state of a pushbutton switch, pressed or not-pressed. (Remember, PORTB on Arduino only has 6 pins) Each time we loop through here, we reset the buttonPressFilter to start as all 1′s. As it is bitwise ANDed with the previous button memories, any button read of a zero value will fall through as a zero, the rest will be left as 1′s. It basically ‘filters’ out any button presses that are not yet stable.

buttonPressFilter = 0xFF;

Here we shift all the memory by one, dumping the oldest reading to make room for the new reading. Then we AND all the old memories together.

for(i=(debounceDepth-1); i>0; i--) {
    buttonMemory[i] = buttonMemory[i-1];
    buttonPressFilter &= buttonMemory[i];
}

Here we read the current status of the switches on PORTB.

buttonRead = PINB;

Now for each pushbutton switch we check if the current read indicates a press. If it does, then we set its memory bit, otherwise we clear it.

for(i=0; i<numButtons; i++) {
    if((buttonRead & bitMask[i]) != 0) { // if current read shows button is pressed
        buttonMemory[0] |= bitMask[i];     // set the memory bit for that button
    } else {
        buttonMemory[0] &= ~(bitMask[i]); // otherwise clear the memory bit for that button
    }
}

Take account of the newest read into memory.

buttonPressFilter &= buttonMemory[0]; // AND the final memory bits into the buttonPressFilter

Now the buttonPressFilter contains the current pressed or non-pressed state of the switches. If any switch has had a consistent value for debounceDepth number of times, then toggle the state in the buttonState array and do whatever it is you want your button to do.

for(i=0; i<numButtons; i++) {
    if((buttonPressFilter & bitMask[i]) != 0) {
        if(buttonHasReleased[i] == true) {
            if(buttonState[i] == 0) {
                // ENTER CODE HERE FOR WHAT YOU WANT TO HAPPEN WHEN BUTTON IS ON
                buttonState[i] = 1;
            } else {
                // ENTER CODE HERE FOR WHAT YOU WANT TO HAPPEN WHEN BUTTON IS OFF
                buttonState[i] = 0;
            }
        }
        buttonHasReleased[i] = false;
    } else {
        buttonHasReleased[i] = true;
    }
}

One final thing to mention is that the debounceDepth value is something that you need to experiment with for the specific switches in your project. Currently with my cheap pushbuttons sitting in a cardboard chassis and wired to a breadboard, I need a value of 10 to get stable results. Using better switches, a stable chassis and a PCB I expect this number to drop.

DIY cardboard MIDI controller

I am planning on using this Arduino based prototype to experiment with fine tuning the firmware for a line of boutique and custom MIDI controllers. The final project will be ported to C using the AVR C library and I will make the whole project open source.

Here is a look at the back. I just used whatever pots I had, so they aren’t matched. The LCD is a serial one from SparkFun.

Underbelly of the cardboard MIDI controller

This driver is a virtual midi device that you can use to route MIDI to, through and from. My Max patch parses the serial data from the Arduino to the IAC Driver. By choosing the IAC Driver as a MIDI input in Live (or any other MIDI capable app) you can then use the serial MIDI CC data sent from the Arduino to control your software.

The MIDI data that the Max patch expects at the serial input is in the standard MIDI format for a CC message; a status byte, a control number and a value. This simple patch just listens for a status byte of 176 which is a control change on channel 1. The baud rate I chose for this patch was 57600. Note that you do not have to use the standard MIDI data rate of 31250 baud.

MIDI Devices

To enable the IAC Driver go to Applications->Utilities->Audio MIDI Setup, click on the MIDI Devices tab and then double click the IAC Driver icon make sure that the Device is online check box is checked.

To use this patch you need the MaxMSP Runtime. Once you have that installed open it up and then open the patch with it. Double click on the midiout object and select the IAC Driver. Then click the button at the top of the chain to start reading the serial port and parsing the data. You should now be able to use  midi learn to map your controllers and start tweaking stuff in realtime with your potentiometers.

Here is what the patch looks like:

Serial to MIDI Max patch

If you own Max just copy the following code and then paste it in a blank patcher.

----------begin_max5_patcher----------
488.3ocuVsrahCCEccxWwUdclQ9QdTlcUpa5h9ETUMxPLTOJwFkXTof5+9X6
.COFjvIjhDgHesu1m64dNIYabDZpdsnEA+BdEhh1FGE4C4BDsabDpludVEu0
uLjR7gd5ePIcSYDqM9vapf4xJinAHE46mUspVppDFelzCA0qLmGctVYT7Zge
ydrQxq1uIK4lYuKUK9ciXloCozT7OwI.kl4tkOwOvFBdaWNcGf4ykhtDPnD6
0+l1cXsxM9IITa1cgkk9S2Vd+ffbg9JN18WxsQMKajJC7xyO87E4ExE4E7P3
ER1I7B6+3kqW3ECovM5EKpD8n5HWs2xv6A+0ZsVx8Pm8nJgMhsvZgoQCY8PW
StAccgu8kQtdsOkqVzGYMcD4jVgqZ.NjUjiwvC.Av8PBbKFeRmtfPxCSdzSy
OaLc+0xRoETe2VeZpWtvRSc2RmL.qOCOxk8bcSM+xUdwnaZnO3cMDbeejQ.t
lIiIw3p.2KIAkx9a.OzbPNl77fYmd8dxrioFehnJo57OovCLW7S4qV8plY6O
1caWBb.ZkhViTwMRs53EcxZdWVVJTG6arRukZaKdGFf2tXyKXHE.hrBDKod2
fDKDLcFU9ciIZ.Phce6brP5b2WRZRHrD99puCwxUbCPxN3q3+JxEVKJ
-----------end_max5_patcher-----------

If you don’t own Max then you can download the patch here.

I will try and put together a more complete patch with user selectable options sometime soon.