{"id":151,"date":"2005-11-04T01:08:29","date_gmt":"2005-11-03T23:08:29","guid":{"rendered":"http:\/\/blogs.bl0rg.net\/netzstaub\/?p=151"},"modified":"2005-11-04T01:08:29","modified_gmt":"2005-11-03T23:08:29","slug":"usb-midi-controller","status":"publish","type":"post","link":"https:\/\/blogs.bl0rg.net\/netzstaub\/2005\/11\/04\/usb-midi-controller\/","title":{"rendered":"USB MIDI Controller"},"content":{"rendered":"

I use Ableton live a lot to jam and to DJ, and using the mouse to
\ncontrol all the parameters got in the way quite often. You can’t
\nselect a scene and turn a knob at the same time, switching between
\nviews was tiresome. I first thought about building a midibox<\/a>, but then decided to build my own midi system
\nusing an AVR microcontroller, which I’m more used to. Blueloop<\/a> helped me a lot
\nwith the schematics, showing me a nice trick to control LEDs using the
\nsame matrix as for the switches (this is not integrated yet,
\nthough).<\/p>\n

\"Alt<\/a><\/div>\n

<\/p>\n

The midi controller is quite simple. It features 33 switches and 56
\npotentiometers. The switches and potentiometers are laid out in a
\nmatrix. You can select a horizontal row by pulling down a port to 0 V,
\nand then reading the switch values on another port, or by going
\nthrough the ADCs in the case of the potentiometers. The actual circuit
\nfor the microcontroller is really really simple. There is an
\noscillator and a resistor for the MIDI output. The rest of the I\/O
\npins go to a pinhead which connects the front panel to the circuit
\nboard.<\/p>\n

There is a second circuit board in the midi controller that
\nconverts the MIDI output of the first circuit to USB. It was an old
\nUSB programmer board I built 2 years ago that was lying around. I
\ndirectly connected the power of the first circuit board to the USB
\nconnector, and connected the MIDI output to the RX pin of the USB
\nprogrammer. I had no 12 Mhz oscillator (the one which I normally use),
\nso I used a 20 Mhz quartz out of an old network card. The board is
\nreally simple too, and consists of a PDIUSBD11 chip by Phillips, which
\ngets commands over I2C and outputs USB, and an ATMEGA8
\nmicrocontroller. Sadly, the PDIUSBD11 is not manufactured any more,
\nwhich is kind of sad, as it is the only USB controller I am aware of
\nthat uses I2C, which spared pins on the microcontroller side. I
\nimplemented the USB MIDI
\nspecification<\/a> out of the specification, and the controller seems
\nto work under Linux and Windows (there is a problem with MacOSX, but I
\nlast checked two years ago and haven’t tried\/debugged it since
\nthen). I can’t publish the whole code for the usb-midi adapter though,
\nas most of it (including the USB stack) was written by Till Harbaum<\/a>.<\/p>\n

\"Alt<\/a><\/div>\n

The matrices are soldered on the front panel, which I made out of a
\nplexiglas sheet through which I drilled holes for the switches and
\npots. I had no real problems with the plexiglas, except that you have
\nto drill quite slowly through it in order not to split it, and that I
\nhad to remove the melt plastic around the holes using a rasp. Each
\nswitch has a diode at one of its outputs, so that two knobs pressed at
\nthe same time can be distinguished on the controller side. The
\npotentiometers are connected to VCC one one side, to the select port
\non the other side, and the variable output is connected to the ADC
\nusing a diode. When selecting a switch or a pot, the select pin is
\nset to GND, all the other pins are set to VCC. Because of the diodes,
\nthe pressed switches or the pots which are not selected are always
\nhigh, and the diode won’t allow them to influence the signal.<\/p>\n

\"Alt<\/a><\/div>\n

<\/p>\n

\"Alt<\/a><\/div>\n

The code on the microcontroller is almost as simple as the circuit
\nboard. A simple ring-buffer interrupt-based UART handling is used to
\nhandle outgoing MIDI data (the midi controller can’t receive MIDI
\nevents).<\/p>\n

\n#define RB_SIZE 16\n#define MIDI_BAUD 31250UL    \/* 31.25 kbps *\/\n\nvolatile char tx_buf[RB_SIZE];\nvolatile char tx_wr = 0, tx_rd = 0;\n#define TX_INCR(a, b) (((a) + (b)) & (RB_SIZE - 1))\n#define UART_TX_OK (UCSRA & _BV(UDRE))\n#define TX_FREE (!(TX_INCR(tx_wr, 1) == tx_rd))\n\nSIGNAL(SIG_UART_TRANS) {\n  if (tx_rd != tx_wr) {\n    UDR = tx_buf[tx_rd];\n    tx_rd = TX_INCR(tx_rd, 1);\n  }\n}\n\nvoid uart_putc(char c) {\n  if (UART_TX_OK && (tx_wr == tx_rd)) {\n    UDR = c;\n  } else {\n    while (TX_INCR(tx_wr, 1) == tx_rd) ;\n    tx_buf[tx_wr] = c;\n    tx_wr = TX_INCR(tx_wr, 1);\n  }\n}\n\nvoid uart_init(void) {\n  tx_wr = tx_rd = 0;\n  \n  \/* set baudrate *\/\n  UBRRL = (((F_CPU) \/ (16 * MIDI_BAUD)) - 1);\n  \/* enable TX, interrupts *\/\n  UCSRB = _BV(TXEN) | _BV(TXCIE);\n\n  sei();\n}\n<\/pre>\n
The static buffer “tx_buf” is used to buffer outgoing serial
\ndata. “tx_wr” and “tx_rd” are used as indices into the ring
\nbuffer. “TX_INCR” handles the indices when a character is added to the
\nring buffer. “TX_FREE” checks if there is free space in the ring
\nbuffer. “UART_TX_OK” checks if the serial interface is ready to send
\nanother character. “SIGNAL(SIG_UART_TRANS)” is the interrupt routine
\nthat is called when a character has successfully been sent. It checks
\nif the ring buffer is empty, and sends the next character if it is
\nnot. “uart_putc” is the API to the UART code, and directly sends the
\ncharacter if the serial interface is ready and the ring buffer is
\nempty. If not, it waits until there is space in the ring buffer, and
\nadds the new character to the ring buffer. “uart_init” handles the
\ninitialization of the serial interface, sets the correctly baudrate,
\nand enables TX and the TX_TRANS interrupt. Finally, interrupts on the
\nAVR are enabled.<\/p>\n
\nvoid io_init(void) {\n  \/* disable watchdog *\/\n  WDTCR = 0;\n\n  \/* DD = 1, output *\/\n  \/* PORT = 1 wenn DD = 0, dann pull-up *\/\n  \/* portd = output *\/\n  DDRD = 0XFF;\n  \n  \/* enable ADC *\/\n  DDRA = 0;\n  PORTA = 0xFF;\n  ADMUX = _BV(ADLAR);\n  ADCSRA = _BV(ADEN)|_BV(ADPS2)|_BV(ADPS1)|_BV(ADPS0);\n  \/\/ ADCSRA = _BV(ADEN);\n\n  uart_init();\n}\n<\/pre>\n
The routine “io_init” initializes the Atmel, first disabling the
\nwatchdog, then setting PORTD to output (which is not really necessary,
\nas the status of the port is set by the switch polling routine). The
\nADC is enabled by setting the PORTA to input, enabling pullup
\nresistors, and enabling the ADC in a 10 bit mode, and using AVCC as
\nreference voltage. Finally the UART is initialized.<\/p>\n
\n\/*** MIDI zeugs ***\/<\/p>\n
#define MIDI_NOTE_ON     0x9
\n#define MIDI_NOTE_OFF    0x8
\n#define MIDI_AFTERTOUCH  0xA
\n#define MIDI_CC          0xB
\n#define MIDI_PROG_CHANGE 0xC
\n#define MIDI_CHAN_PRESS  0xD
\n#define MIDI_PITCH_WHEEL 0xE<\/p>\n
#define MIDI_STATUS_TYPE(c) (((c) & 0xF0) >> 4)
\n#define MIDI_STATUS_CHAN(c) ((c) & 0xF)<\/p>\n
static inline midi_is_status(char c) {
\n  return (c & 0x80);
\n}<\/p>\n
void midi_send_note_on(unsigned char channel, unsigned char note, unsigned char velocity) {
\n  uart_putc((MIDI_NOTE_ON <\/p>\n
The midi controller sends three types of midi messages. When a switch
\nis pressed, it sends a note on message, when a switch is release, it
\nsends a note off message, and when a pot is modified it sends a
\ncontrol channel message. All three messages are three bytes long and
\nsent directly to the uart using \"uart_putc\".<\/p>\n
\n#define LED_BUTTON_PORT     D
\n#define PORTLED_BUTTON_PORT PORTD
\n#define DDRLED_BUTTON_PORT  DDRD
\n#define PINLED_BUTTON_PORT  PIND<\/p>\n
#define SET_PIN_OUTPUT(port, pin) { DDR ## port |= _BV(pin); }
\n#define SET_PIN_INPUT(port, pin) { DDR ## port &= ~(_BV(pin)); }
\n#define SET_PIN_INPUT_PULLUP(port, pin) { SET_PIN_INPUT(port, pin); PORT ## port |= _BV(pin); }
\n#define SET_PIN_LOW(port, pin) { PORT ## port &= ~(_BV(pin)); }
\n#define SET_PIN_HIGH(port, pin) { PORT ## port |= _BV(pin); }
\n#define PIN_VALUE(port, pin) ((PIN ## port & _BV(pin)) ? 1 : 0)<\/p>\n
#define NUM_BUTTONS 30<\/p>\n
#define BUTTON_STATUS(i) (button_status[(i)] & 0xF)
\n#define SET_BUTTON_STATUS(i, val) { button_status[(i)] = button_status[(i)] & 0xF0 | (val); }
\n#define LED_STATUS(i) ((button_status[(i)] >> 4) & 0xF)
\n#define SET_LED_STATUS(i, val) { button_status[(i)] = button_status[(i)] & 0xF | ((val)  1 (bounce?) -> 2
\n   wenn knopf auf 1 dann nachricht senden (note on), wieder auf 0 (note off)
\n*\/<\/p>\n
#define BUTTON_ROWS 5
\nunsigned char button_status[BUTTON_ROWS * 8];<\/p>\n
void init_buttons(void) {
\n  int i, j;
\n  for (i = 0; i