Introduction

By a couple of months I have started a project for creating a series of low-cost, open source, electronic musical instruments.

Dum-De-Dum is the first one of the series for which I have explored; an alternative way than using pressure sensitive pads to make a drum machine, reducing the costs of the components without penalising the performances of the final build.

Drafting the Idea

The above images shows the quoted distribution of the pads and the construction details of the weight sensors supporting the pads.

 

Making a Cheap Drum Machine

According with the guidelines I drafted for designing a series of electronic musical instruments, the idea of the drum machine follows some basic assumptions.

Between vintage and poor (may be so poor?) materials the design should be limited to  cardboard and super compressed cardboard, eventually MDF where special robustness is needed.

It is a must finding alternative technologies and methods than those usually adopted to reach the same result. If is not a fixation, just a way to discover new possibilities at dramatically lower production costs. In this case I have searched for something alternative than those touch sensitive pads for the user interaction, the key components of an electronic drum machine.

Despite the material and components, the final result is expected to be usable as well as an analogous commercial device.

Two commercial drum machine

 

Components and Methods

The design of the device and pads diameter (80. mm.) follows the most diffuses drum machines; the image below shows the quoted draft and pads distribution.

The base and percussion surface, of the pads has been obtained from a MDF sheet 3mm thick, while the remaining parts are built with cardboard.

To create the five sensitive pads I have opted for an unconventional solution: a set of five cheap weight sensors. The kit with the sensors, including their A/D amplifiers and converters based on HX711 costs about-5$. All together!

These sensors have a very good excursion, high sensitivity and can measure up to 5kg. All these parameters are in the range needed for the musical alternative use.

The drum A/D HX711 converters and the main connector to the Arduino board

 

Construction Details

The making of the construction of the cardboard drum machine is shown in the image gallery below. The components assembly has been done with hot glue, excluding the sensors, fixed to the pads and the MDF base with a couple of Allen screws.

 

{gallery} Dum-De-Dum Making-Of

The 3mm MDF base. This will be the support of the weight sensors and pads

Cutting the robust base ...

Top view of the bottom side of the pad assembly (top surface)

This will be the surface cover of the structure. The entire forces are discarded on the pads and the sensors support, so this part does not need special robustness.

The double-sided pads. The top side is 3mm MDF, exposed to the user interaction forces while the bottom is glued cardboard, fixed on the weight sensors.

The pads ready to be assembled

The linear weight sensors screwed to the 3mm MDF base with the pads fixed on top.

Assembled view of the drum pads skeleton. The weight sensors can support up to 5Kg pressure

The pads assembled with the cardboard top cover

The 3mm MDF (bottom view) with an extra cardboard sheet glued on it.

Red pads rubber on top?

Naaa.... Better black, Be serious

Every pad sensor has its own HX711 A/D amplifier and converter. Around a cardboard border to complete the build

Bottom view of the structure

All te sensors signals collected by a small PCB and connected to the Arduino

The bottom of the Dum-De-Dum box. Initially the Arduino was external to the box but in its final assembly it is hosted inside the box.

Top view of the finished Dum-De-Dum (the cardboard drum )

 

Testing and Playing

 

The below video shows testing and playing (yes, it's me live playing a random rhythm ) the Dum-De-Dum. Controlled by an Arduino board, the incoming sensors data are converted to a set of five predefined MIDI notes; the detected pressure intensity for every sensor is converted to a corresponding velocity value sent together with the associated MIDI note. This device can be used for live performances as well as to record rhythm sequences. In the video example the MIDI data are processed by Hydrogen, a great open source multi platform drum application.

 

Arduino Software

The control of the sensor and MIDI out sending has been developed on a Arduino UNO board. The last updated version of the application is available on GitHub: https://github.com/alicemirror/DumDeDum

The sketch import two libraries: Arduino MIDI and MX711 The application consists of two parts: the sensors acquisition and the MIDI processing and sending through the Serial Tx.

There is an interesting part that it is the worth to dive in detail; as I have already used these weight sensors for other kind of applications in past, I have already chosen the Bogde HX711 Arduino library as it is efficient and very flexible.

Until now, every sensor uses two pins; one is the clock signal sent from the Arduino and the other is the data channel. As far as the HX711 library is built it is possible to instantiate multiple sensor at the same time. In our case we should manage the readings fast and synched so I have done a test, discouraged if the weight sensor is used for measure weight, not in this alternative way: I have connected a single clock pin to all the sensors and one pin every data channel.

 

// Number of weight sensor pads
#define NUM_PADS 5

// Fixed MIDI Channel (the default percussions channel 10)
#define MIDI_CHANNEL 10

/* 
 * Note duration (ms)
 * This value express the fixed duration of a note before the noteOff is sent.
 */
#define NOTE_DURATION 5

#define PAD_CLK 2     // Clock PIN
#define PAD1 3         // Pad 1 PIN
#define PAD2 4         // Pad 2 PIN
#define PAD3 5         // Pad 3 PIN
#define PAD4 6         // Pad 4 PIN
#define PAD5 7         // Pad 5 PIN


// Define the weight sensor instance for every pad
HX711 pad0(PAD1, PAD_CLK);
HX711 pad1(PAD2, PAD_CLK);
HX711 pad2(PAD3, PAD_CLK);
HX711 pad3(PAD4, PAD_CLK);
HX711 pad4(PAD5, PAD_CLK);

 

Then after the five instances of the HX711 library have been created (with always the same PAD_CLK pin assigned), the setup() initialisation function create a vector of library instances so in tis possible send the data to the library in a loop.

 

// Initialization
void setup() {
  int j;
  
  // Create the pads vector to manage the weight sensors in loops
  pads[0] = &pad0;
  pads[1] = &pad1;
  pads[2] = &pad2;
  pads[3] = &pad3;
  pads[4] = &pad4;

  // Setup the pitch notes associated to every pad
  padsMap[0] = 38;
  padsMap[1] = 39;
  padsMap[2] = 40;
  padsMap[3] = 41;
  padsMap[4] = 42;

  // Initialize the sensor readings and set tare
  for(j = 0; j < 3; j++) {
      // As "gain" value is ommited; the default value 128 is used by the library
      pads[j]->set_scale();
      pads[j]->tare();
  }

...

 

Circuit and wiring

Wiring the components to the Arduino board is almost easy. Pins 2 to 7 are connected, respectively, to the clock and the five sensors data lines. Then a typical MIDI out interface is wired to the Tx pin1, GND and VCC.

The analog input (via a 10K potentiometer) and the program mode button is for further versions. I plan to include a programming mode to enable the potentiometer and setup the sensitivity of the pads, saving the last setting on the non-volatile EPROM of the Arduino (just an integer value). The below image shows the HX711 wiring to both sensor and Arduino side.