If you are concerned about the delays though, the sketch could be changed so instead of doing a spinloop and delay, it maintains an “is_triggered” state for each piezo, then checks and increments an individual “t” value for each piezo. Then you read all the piezos at once, and then decide to send midiOn or not.

I was thinking to the worst case: when you hit two pads exactly at the same time or with a few microsecond delay . so i suppose that the piezo pulse (from threshold to threshold ) is a few millisecond long, right? .The code scans the first analog input, wait for a “t” time , send a midi on note, then wait for a “t” delay and then a midi off note. after that repeats the same procedure with analog input 2 … so after hitting a pad there’s at least 2t delay. In the worst case i mention above the second hit is completely lost. I am missing something? maybe i’m too much pessimist, maybe the worst case happens very very rarely.

thanks, bye!

very very good project!

I have just one simple question. Is this module polyphonic?
if i understand correctly the code the arduino scans just one analog input at time…

thanks, bye!

I was looking for electronic drums in the DIY domain, and I found Wyatt’s work. After a while I also discovered yours and found it really inspiring, and so I started my own implementation.

Since there are people asking, there is a way to interface arduino with MIDI and Linux, through USB and no additional hardware, through ttymidi [1]. This is the road that I follow, and you can also check my progress in my blog! [2]

I believe that there are plenty of audio software solutions available for Linux, although it is still tricky to succeed in configuring everything smoothly.

-prf

[1] – http://www.varal.org/ttymidi/
[2] – http://www.prfbase.com/porfyros/2010/01/e-tampourlo/

Ive succesfully connected 1 pot using a arduino mega, s2midi and midi yoke to ableton live. Although there was some latency it was barely noticable. The thing is, I want to use around 16 pots and 16 switches. Since my programming skills are far from perfect, ive run into some problems hacking the attached analogcc code from s2midi to accept multiple pots on different analog pins. Is there anyone who has tried this before and would like to share their code?

here is the original code from their website:

// Example of Arduino feeding S2MIDI CC messages

int midiChannel = 9;
int outPin = 13;       // the number of the output pin
int analogPin = 5;

// Analog smoothing stuff
int lastAnalog = 0;
int analogSmooth = 2;  // Amount of change needed to send control change

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  int reading = 0;

// Do analog line
  reading = analogRead(analogPin)/8; // change 0-1024 into 0-127
  if (abs(reading-lastAnalog) > analogSmooth) {
    lastAnalog = reading;
    controlChange(midiChannel,10,reading);  // Send CC10
  }
}

// Send a MIDI control change
void controlChange(byte channel, byte controller, byte value) {
   midiMsg(channel+0xB0, controller, value);
}

// Send a general MIDI message
void midiMsg(byte cmd, byte data1, byte data2) {
  digitalWrite(outPin,HIGH);  // indicate we're sending MIDI data
  Serial.print(cmd, BYTE);
  Serial.print(data1, BYTE);
  Serial.print(data2, BYTE);
  digitalWrite(outPin,LOW);
}

Also, there have been several references to little-scale’s blog and I’ve been particulary interested in this entry:
http://little-scale.blogspot.com/2007/11/more-pots-and-switches-to-midi-data.html

maybe sometime…

I suspect the easiest approach would be to have a small program that sits on the Arduino’s serial port and sends/receives OSC messages. Many audio programs support OSC, which is kind of like MIDI over UDP if you’ve never heard of it. OSC is nice because it’s very simple and very flexible. And just look at all the stuff people have built for OSC.

Of course there are many ways for an Arduino to signal a computer (serial, ethernet, midi…), but I’m specifically interested in using MIDI messages for a velocity-sensitive soundboard (fartbonker-type) application, while not spending $500+ on proprietary software.

I can see why Ladyada made the WaveShield — compact, low power, low-resource audio is a PITA with Arduino.

Thanks for sharing!

Although I didn’t understand this part of your code- could you assist please?

“….if(val 127)….”

and

“…noteOn(drumchan,note_bassdrum, output)….”

(what is the output in this case?)

Thanks, and great work todbot!

Thanks for the code to this piezo trigger!
I’ve actually made it better and I wanted to share that with you all.

I’ve commented the code as good as I’m able to.
One thing though: It does not send an OFF message to Logic, or Logic does not interpret it that way, it just interprets it like a zero velocity hit. Don’t know why, really.
Please get back to me if you have the answer.

Anyway, this works perfectly for me:

// what midi channel we're sending on
// ranges from 0-15
#define drumchan           1

// general midi drum notes
#define note_bassdrum     36

// define the pins we use
#define piezoAPin  0
#define ledPin     13  // for midi out status

// analog threshold for piezo sensing
#define PIEZOTHRESHOLD 80

int val;
int output;

void setup()
{
  pinMode(ledPin, OUTPUT);
  Serial.begin(31250);   // set MIDI baud rate
}

void loop()
{
  static int prevval;

  //read analog signal from piezo.
  val = analogRead(piezoAPin);

  //if the analogue value exceeds the threshold, engage the if statement.
  if(val>=PIEZOTHRESHOLD)
  {
    //add the value to a static variable to keep the previous analogue read value from last loop repetition.
    prevval+=val;

    //when the previous value is larger than the current value, we've detected a peak in the analogue signal.
    if(val 127)
      {
        noteOn(drumchan,note_bassdrum, 127);
      }
      //in all other cases, the value will be the calculated value.
      else
      {
        noteOn(drumchan,note_bassdrum, output);
      }
      //when MIDI output is set, deactivate the MIDI signal again and reset the 'previous' value to 0 to be ready for a new peak.
      noteOff(drumchan,note_bassdrum,0);
      prevval=0;
      //and finally a short delay for not overflowing the UART.
      delay(100);
    }

  }
}