Drumleds

Project Drumleds
Een project wat ik voor een bekende van mij gedaan heb, tevens mijn eerste project bij revspace. Het betreft een kastje wat leds laat flitsen wanneer de drummer de basskick intrapt. Die bekende van mij heeft dit kastje momenteel in gebruik op een drumstel wat hij geheel zelf gemaakt heeft.
Status	Completed
Contact	merethan
Last Update	2017-05-25

Project

Dit project is begonnen toen iemand die ik kende via een muzikantencentrum mij benaderde met de vraag of ik hem kon helpen. Hij was een eigen drumstel aan het bouwen en als show-element wilde hij een ledstrip met witte powerleds in de bassdrum laten knipperen op het ritme van de kick. Zelf had hij al een paar onderdelen (voeding, ledstrip, sensor). Aan mij de vraag of ik iets kon maken om het geheel aan elkaar te knopen.

Onderdelen

Behuizing

Een onderdeel waar je gemakkelijk overheen kijkt is de behuizing. Dat alles veilig zit opgeborgen is een must voor iets wat van optreden naar optreden gaat, daarom heb ik gekozen voor een project box van Hammond Manufacturing. Doet gewoon wat het moet doen. Gewoon goed.

Voedingen

De grote voeding (het witte blok) gaat van 230v naar 12v, met een vermogen van 2.5A (volgens mij). Genoeg prik om de powerleds van stroom te voorzien in elk geval. Diezelfde voeding wordt ook voor de schakel-elektronica gebruikt via een DC-DC converter (rode print), die van de 12v naar 5v gaat. Deze 5v voed het relais-board en de Arduino Pro mini.

Arduino

Tja wat anders. Een Arduino. In dit project heb ik een Arduino Pro mini 5v model gebruikt. Tamelijk klein model, maar meer was er niet nodig.

Relais-board

Voor dit project heb ik een print met twee relais gebruikt, ook al gebruik ik nu slecht een enkele relais. Ik voorzie dat de beste man binnenkort meer lampjes op zijn drumstel wil, vandaar dat die tweede er maar alvast zit. (En het was de kleinste print die ik had liggen.) De relais worden door een opto-coupler aangestuurd die van 3.3v (het voltage op de GPIO's van de Arduino) gelijk ook naar 5v gaan, en de relais activeren. De relais zouden tot 250v AC kunnen hebben, nu schakelen ze slechts 12v DC.

Sensor

Een RT-10K van Roland. Gewoon een goede drumtrigger, verder niets speciaals aan. Het zijn in feite microfoontjes met een andere spoelwikkeling waardoor ze een relatief hoog voltage genereren. Ook hebben ze geen membraam wat mee beweegt op de trilling in de lucht maar een schuimpje wat tegen het vel van een tom of kick moet zitten. Er zit ook een mooi beugeltje bij om het stevig aan een trommel vast te maken.

Werking

WIP

Verbeterpunten

Mosfets! Drumtrigger ging over de 5v (max meetbereik Pro mini 5v).

Arduino code

/*

  Drumkit lights is a custom piece of code written
  to switch on/off a LED strip in a drumkit.
  Essentially, it is a simple system listening on
  analog inputs and switching digital ones accordingly.
  The analog inputs are to be wired to drumtriggers
  (those are basically very weird microphones) and
  the outputs to mosfets or relay boards, controlling LEDs.
  Currently it is written to run on a Pro mini board.

• /

void setup() {

 // IO setup
 pinMode(2, OUTPUT); // First relay
 pinMode(3, OUTPUT); // Second relay
 pinMode(4, OUTPUT); // Third relay
 pinMode(5, OUTPUT); // Fourth relay
 pinMode(13, OUTPUT); // Arduino PCB LED

 // Initialize outputs
 digitalWrite(2, HIGH); // Open the first relay
 digitalWrite(3, HIGH); // Open the second relay
 digitalWrite(4, HIGH); // Open the third relay
 digitalWrite(5, HIGH); // Open the fourth relay
 digitalWrite(13, LOW); // Turn off the PCB LED

}

// Default values const unsigned short flashduration = 42; // Duration, in miliseconds const unsigned int calibrationinterval = 250; // Minimum interval in between threshold calibrations, in miliseconds

// Global vars const unsigned short iocount = 4; // The number of drumtrigger input and led output pairs this piece of software has to process unsigned short current[iocount] = {0, 0, 0, 0}; // The last measured value on an drumtrigger's analog in port unsigned short peakvalue[iocount] = {0, 0, 0, 0}; // The highest current value seen so far on the drumtrigger's port unsigned short threshold[iocount] = {0, 0, 0, 0}; // The analog input value we consider a strike for this port unsigned long lasttrigger[iocount] = {0, 0, 0, 0}; // The last moment a strike was detected on this port (in miliseconds, counted since the start of the program) unsigned long lastcalcycle = 0; // The last moment a threshold calibration cycle was performed (in miliseconds, counted since the start of the program) const unsigned short smoothcount = 128; // The number of samples the smoothing algorithm operates with unsigned short smoothiter[iocount] = {0, 0, 0, 0}; // The iterator for each input, used for cycling trough the history array used for smoothing each input unsigned short currenthistory[iocount][smoothcount]; // A two-dimensional array holding a history for each analog input, where the history is $smoothcount in size

void loop() {

 // Each input is processed in a sequential fashion
 for (int i = 0; i < iocount; i++) {
   // The first part is about establishing whether a piece of the drumkit was struck or not
   current[i] = analogRead(i); // Read the input on analog pin i. Goes from 0-1023, representing 0-5v for this model Arduino

   if (current[i] > threshold[i]) {
     lasttrigger[i] = millis(); // Write time of last trigger
   }

   // The second part is about turning lights on or off, depending on how long ago a hit was detected
   if ((millis() - lasttrigger[i]) < flashduration) {
     digitalWrite(i + 2, LOW); // Close the relay
     digitalWrite(13, HIGH); // Activate the LED
   } else {
     digitalWrite(i + 2, HIGH); // Open the relay
     digitalWrite(13, LOW); // Turn off the LED
   }

   // The third part is about self-calibrating threshold values
   if (current[i] > peakvalue[i]) {
     peakvalue[i] = current[i]; // Save the highest detected value so far
   }

   threshold[i] = peakvalue[i] / 1.2; // ~83% of the highest peak so far is considered the threshold

   // Lowering the threshold is based on current value. But since it is noise, smoothing is needed. Therefore, a history needs to be kept
   currenthistory[i][smoothiter[i]] = current[i];
   if (smoothiter[i] < (smoothcount - 1)) {
     smoothiter[i]++;
   } else {
     smoothiter[i] = 0;
   }

   unsigned long totalcurr = 0;
   for (int j = 0; j < smoothcount; j++) {
     totalcurr += currenthistory[i][j];
   }
   unsigned short smoothed = totalcurr / smoothcount;

   if ((millis() - lastcalcycle) > calibrationinterval) {
     lastcalcycle = millis(); // Write time of last threshold calibration

     if (smoothed < (peakvalue[i] / 2)) { // Only reduce the peakvalue if the noise level is less than 50% of the peakvalue
       peakvalue[i]--;
     }
   }
 }

}