Final project Initial conception (Febuary 2022)

Learning to play any musical instrument takes a very long time and a lot of effort. To enjoy music hardly takes time at all. To bridge the gap between playing and enjoying music, I propose to make an instrument that limits the choice of the player in a way that they can always play agreeable music.

This instrument will be largely inspired by this YouTube video:

The instrument will be a midi-device based on a piano keyboard and it will be built with following requirements:

• the player can provide a specific emotional state in which music can be played
• two keys are available to play the chords associated with the emotional state
• 24 keys are arranged in a circular fashion. Only the keys that agree with the played chord will be playable.
  • The circular keyboard makes it easier to play tunes with one hand and to easily play octave based basslines.
• keys are force sensitive. Exerted force can be mapped to midi inputs to simulate aftertouch.

A rough demo can be played in this p5 program. Pressing the chord keys too rapidly will crash the browser sound engine (for now)

The final design could look like this:

Planning

Final project, as it turned out

Final Presentation Slide

Enclosure design and fabrication

The enclosure of the device was designed to have a small selection of keys on the left and a large selection of keys on the right. The keys on the left play the chords, starting at the top and the chords progress in a clockwise fashion. The keys on the right hand side change, based on the chord that the user just pressed.

The enclosure is made from a stack of lasercut plywood. Designed in Fusion360 and sliced in Slicer for Fusion.

Input

Buttons

For the first iteration of the “feib” instrument I thought of making my own switches entirely from scratch by making a piece of metal touch two separated copper traces on my PCB.

Part of the switch is made up of two copper traces on the PCB that are made to be touched by another piece of copper foil

To make my own buttons would also involve designing and creating my own springs. That proved too much work so I opted for another solution.

Eventually, the buttons I used were nothing special in terms of input. I used the switch-part of commercially available arcade buttons. T

The switches from arcade buttons were repurposed

o prevent me from having to use resistors I used the internal pull-up resistor of the Attiny3216 microcontroller I used.All buttons were initialized using the following code:

for (uint8_t iButtonPin=0; iButtonPin<NBUTTONS; iButtonPin++)
    pinMode(iButtonPin, INPUT_PULLUP);

As the state of the buttons was only sampled for 100 times per second, I didn’t need debouncing, as button bounce occurs of much shorter time frames.

All eight button states could be stored as separate bits in one byte making it quite easy to perform edge detection for all eight buttons at once using binary operations:

void update(){
    lastPollButtonStates = inputState.buttons;

    // get current button state here
    // ....

    buttonsFallingEdge = ~inputState.buttons & lastPollButtonStates;
    buttonsRisingEdge = ~lastPollButtonStates & inputState.buttons;
}

// Functions below are there to get state of individual 
// bits in the bytes representing the state of all 8 buttons
bool getButtonDown(uint8_t buttonIndex)
{
    return (inputState.buttons & (1 << buttonOrder[buttonIndex]));
}

bool getButtonPressed(uint8_t buttonIndex)
{
    return buttonsRisingEdge & (1 << buttonOrder[buttonIndex]);
}

bool getButtonReleased(uint8_t buttonIndex)
{
    return buttonsFallingEdge & (1 << buttonOrder[buttonIndex]);
}

Rotary encoder

A rotary encoder is just a bunch of switched, turning on and off when a spindle is turned. The order in which the switches are activated determine the direction into which the spindle is turned.

The rotary encoder to select the chord progression

I used a rotary encoder library by Matthias Hertel. I had to adapt the example files a bit because these included defines specifically for the Arduino Uno while I was using an Attiny3216. For each “click” of the encoder, the encoder library code returned an increment of two, so this could be divided by two to get the actual position.

To use the encoder to select from a limited number of menu items I simply used the modulo operator:

    chordIndex = (keyboard->chordKeys->inputState.knobPosition % 10);

Force sensors

To enable aftertouch I used the conductive properties of carbon foam, inspired by an instructable the I’ve seen years ago. The carbon foam that is used to ship integrated circuits is slightly conductive. It gets more conductive when the material is more compressed. Putting a piece of carbon foam in a voltage divider circuit will and connecting the output to an analog input pin, a very simple and cheap pressure sensor is made.

The carbon foam was placed as a resistor in a voltage divider

I was not interested in exact Newtons, Pascals or any other measure. Even non-linearity an hysteresis wouldn’t bother me, as the force readings would eventually be converted into a number used in the midi protocol, ranging from 0 to 128. Accuracy was not an issue.

When making the instrument I opted out from making every key force sensitive. By making the lid of the device rest on four pieces of foam I was able to read the pressure in four corners of the device.

An M3 bolt with an acorn nut at the end rests on a piece of carbon foam. The acorn nut acted as a ball-in-socket so bolt was able to rotate freely as to make the sensor only register downward pressure.	The carbon foam rests on a piece of copper-clad epoxy (PCB) with two separate pads.

Unfortunately I wasn’t able to make this work properly as an after touch function due to the limitations of the midi receiver.

Output

WS2812 RGB LEDs

To light up the buttons on the “feib” instrument I used WS2812 LEDs, also called NeoPixels. I used the NeoPixel Static library, as the standard library didn’t play well with I2C.

I cut a strip of NeoPixels to reconnect the using wires	A string of LEDs mounted on backplates, with holes for strain relief.

The LEDs needed to be cut up and resoldered because the needed to be part of a new enclosure for the buttons on my device. The original button enclosures were not at all translucent.

The new button enclosure consists of a shell, an LED backplate, a top cap and a bottom cap.

The backside of the top panel of the “feib” device. The LEDs in the buttons are all linked together.

OLED display

The “feib” device contains an OLED display to show the state of the device. I found an OLED display that was small enough.

The only library I could find to work with the display ran on an ESP8266.

Bill of Materials

Main Board ESP8266

Tone board

Buttons and LEDs

The tactile switches are repurposed from existing 24mm arcade buttons from AliExpress at $0.27 per piece for a total cost of 20x0.27=$5.4.

The WS2812 LEDs were cut from a strip of LEDs from AliExpress at $0.062 per piece, for a total cost of 20x0.062=$1.24.

Enclosure and wiring

For the enclosure I used an estimated 2m^2 of 3mm thick multiplex at $18 per m^2, for a total of $36,- The wiring is estimated to be a total of $5,-.

The total cost of materials of the device would be an estimate $60,-. The most efficient way to cut the costs would be to more economically cut the slices of the enclosure from the available wooden plates.

Files

• Presentation to Neil
• Enclosure and button design
• Tone keyboard PCB
• Main board PCB
• Tone keyboard firmware
• Main keyboard firmware