Published October 17, 2021 © CC BY-NC

ARKeytar - Arduino Based MIDI Controller Keytar

ARKeytar is an expressive Arduino based MIDI controller shaped as a maple wood keytar, with two softpots, a MIDI keyboard and CC controls.

AdvancedShowcase (no instructions)4,676

ARKeytar - Arduino Based MIDI Controller Keytar

Things used in this project

Hardware components

Arduino Nano R3

SparkFun SoftPot Membrane Potentiometer - 500mm

Two softpots for the two ARKeytar "strings"

Rotary potentiometer (generic)

Potentiometer, Slide

Texas Instruments Shift Register- Parallel to Serial

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)

Story

The story

The idea for the realization of this MIDI controller came after seeing what some people could do with softpots, Arduino, and musical instruments together. I found that some applications were really interesting.

I only found that there was a lack of instruments that were not just trying to emulate a guitar or adding a pitch control to an existing keyboard. So I decided to create an instrument that allows to play with both hands two different sounds on different MIDI channels (like one can do on many synthesizers) but with a very different kind of control with one hand. The aim is not emulating a guitar, but giving the possibility to play virtual or hardware synths in a different but not so drastically new way.

In order to make a single instrument capable of delivering these aspects, I chose the shape of a guitar, so to easily handle it both standing and sitting. In this case, a high playing angle is better for the positioning of the right hand playing the keyboard.

This project has been realized in my free time and required almost an year of non continuous work.

Possible playing positions

The name ARKeytar came quite logically: traditionally, the musical instruments that put together keyboards and guitars are called keytars. This one relies on Arduino in order to generate and send midi messages, hence it became ARKeytar.

The Arduino Circuitry and Code Logic

An Arduino Nano or equivalent board is the core of the ARKeytar. It generates the notes and pitch bend messages based on where and how the soft pots are touched, and listens to the incoming MIDI keyboard messages. The board takes all these messages and sends them to the MIDI out port, towards any virtual or hardware synth. The original keyboard circuits are left untouched. The connections are made between the keyboard's MIDI out and the MIDI in circuit connected to the Arduino serial RX port.

Circuitry seen from behind. On top left, the powerbank; at the center, the Nano and the dip switches. On the right the MIDI in and out circuitry. In the bottom part, the keyboard pre-existing circuits and the connectrions to the potentiometers for the CC messages and to sustain and MIDI out port.

The loop cycle reads continuously the two softpots and, if they are touched, a note on message is sent based on where the touch happened. A map function maps the analog value and obtains the midi note number to play according to the note range set for the softpots on the neck.

Then, if the softpots are released, a note off message is sent, otherwise, until the pressure continues, pitch bend messages are sent in order to control the pitch of the note continuously. The pitch bend range can be selected between +-12 and +-24 from the controls, and it must coincide with the one set on the target synth.

New notes are always played without pitch, which is added only if a movement of the finger is subsequently detected.

The pitch bend can be varied continuously, but, sometimes, it could be hard to stop the sliding finger on a note with exact pitch. I introduced a pitch snap function, that allows the pitch to be kept on the one of an exact note, regardless the real position of the finger, if it is close enough to a note. The width of this snap area can be selected from 0 (no snap, pitch follows the finger only) to 1 (no glide between notes, but one semitone steps). I wanted to save some computational burden for the Arduino, so I placed two tables of exact pitch values before the setup. One table refers to a pitch range of +-12 semitones, the other one to +-24. The tables are read at the proper position to retrieve the exact pitch value to be applied during pitch snap. I wrote a python code (attached) to compute these values, and it can be used also to set other custom pitch ranges.

Since I am not a guitar player, I attached to the neck some adhesives to indicate the position of the notes with the same color code of a piano keyboard, to which I'm used to. The second string is transposed of a fourth (5 semitones) with respect to the first one.

The loop periodically asks the serial buffer if any message came from the keyboard. If so, these messages are printed to the serial TX port. This is done also when waiting between the analogRead functions. Performing many TX port reads means that no messages are received incomplete or missed completely.

Some settings can be read by the ARKeytar on startup. These settings are given through a series of dip switches. These switches are managed with two 74HC165 shift registers. The first four give the indication for the MIDI channel onto which to send the notes generated by the softpots, the next eight determine the targets for the control change messages generated by two potentiometers on the body of the instrument. Other switches can be used for other purposes, for example to change the pitch range.

Regarding the circuits, I didn't invent anything. I put together many pieces of circuits I found from other sources. I have to thank in particular:

Notes and Volts for the MIDI circuits

Coagula for inspiration and softpots circuits

This article for using the shift register

The Maple Body and Neck

Both the ARKeytar body and neck are made of maple wood.

The shape is quite ergonomic, but the dimensions have been determined following the dimensions of the keyboard and circuitry. In order to save space, the main circuit is placed below the keyboard keybed.

I started from a 6.5kg solid maple slab and cut away roughly some parts to get closer to the correct perimeter.

Firts phase of body manufacturing

Step after step, with a mill and a belt sander, finer refinements were made, and the final internal and external dimensions were determined in order to fit all the components.

Room for the neck is created, material is removed where the keyboard keys will be placed. The central part is not cleared yet, since it was needed to screw the body to a support, under the mill.

A housing for the battery was milled, and the support for the neck was thinned and prepared for the holes. The surface around the cavities was lowered by 3 mm in order to accomodate the polycarbonate sheet onto which the circuits are screwed.

Preparation for the holes for the screws that keep the neck in position

The body is nearly finished. Holes for fixing the various parts are still missing

Meanwhile, the main circuit and the keyboard circuit were screwed to a polycarbonate base in order to move it in one piece and make indepentent from the wooden body in case maintenance is necessary. Several holes are also present to fix it to the wooden base with screws.

Main circuit, keyboard circuit and potentiometers screwed to the polycarbonate base. Some connections are still missing here

Plexiglass parts keep all the keyboard circuits in position

Also the neck was manufactured in this phase. It is made from maple wood too, and weighs around 700 gr. The softpots are placed onto a long polycarbonate piece, in order to make it detachable from the wood. An 9 pin connector from an old PC is used to connect it to the rest of the circuit. The connector is soldered with wires to the softpots pins. I found many warnings on performing this operation, since high temperatures may damage the pots. I payed attention to touching the pins with the soldering iron and wire for the least time possible. I didn't enounter any problem.

Neck with the softpots. A 9 pin connector from an old PC is used for connecting the neck and the main board. Note that the cable stays attached to the body, and the connector is detaced under the softpots pins.

Once all the parts parts fitted together, also the connections between the parts and the external ports were made. I used a polycarbonate piece to position the connectors. Then, a cap keeps everything in position.

MIDI out port and keyboard sustain switch port

A wooden cap was also made to close all the components inside the body. This part is very thin and delicate, so care was used to handle it. It was manufactured using standard fretsaw. Wooden cyclinders were glued through holes in the cover to fix the cover itself to the rest of the body with passing-through screws.

The cap also has three holes for the original keyboard transpose and function buttons, and a slot for the potentiometers. A hole for the general power switch is also present.

Maple body cover

With all parts ready, the assembly phase could start:

Keyboard and keyboard circuits in place. The main circuit lies under the keybed. At the center of the blue circle at the bottom right is the keyboard original joysick

Circuits, body and body cover assembled for the first time

Once I was sure that everything could fit properly, I finished all the parts with the last details. The edges were smoothed, the neck was completed with two caps, one for each end.

Body with refined and smoothed edges

Neck with its wooden caps

Finally, colored oil was applied to the body, and transparent oil to the neck.

Painting the body

The wooden body, at the end of the work, weighted around 2 kg. The total weight of the ARKeytar is around 4.5 kg, similar to many electric guitars. The external dimensions are 104 x 38 x 4.8 cm.

All the screws used to fix the structural parts were M4. Maple wood is very compact and can be drilled with a 3.4 mm drill bit so the thread can be created by just screwing in the screws slowly. The resulting threads appear to be resistant and durable.

The Result

Controlling virtual and physical instruments

Being the ARKeytar a MIDI controller, it is possible to play both virtual and physial synthesizers. No sound is emitted by the ARKeytar itself, so the sound is completely up to the VST or synth you are using.

In the following video, I played the intro of Dream Theater song Octavarium, which is particularly suited for the ARKeytar, since it was originally played by keyboard player Jordan Rudess on a Continuum, an instrument made of a keyless smooth surface that allows the player to control continuously the notes pitch.

The strings are controlled by the ARKeytar regular keyboard on a Motif XS7 synth. Instead, the potentiometers on the neck control the Vital VST synth that is used to replicate the Continuum part. After recording that parts, I separately recorded an additional string bass part that was added to the mix.

Octavarium (Intro) - Played on ARKeytar

In order to maximise the note range, which is quite broad in this song, I used the function in the code, at lines 308-337, that allows me to apply the octave transpose controls only on the second potentiometer. In this way I coud traspose the second pot down by an octave and use it for the lower notes.

ARKeytar parts

(1) Softpots, (2) Power on switch, (3) 25 keys MIDI keyboard, (4) Rotaty potentiometer, (5) Linear potentiometer, (6) Original MIDI keyboard potentiometer, (7) Original MIDI keyboard joystick, (8) Original MIDI keyboard octave and settings buttons, (9) Strap anchor buttons, (10) Arduino Nano USB port, (11) Octave buttons, (12) Dip switches, (13) Panic button, (14) LED and serial port switches, (15) MIDI and sustain ports, (16) Powerbank USB port, (17) Powerbank

Code

/*
ARKeytar v5.21
2022-05-01, Andrea Gregorini
*/


#include <MIDI.h>
MIDI_CREATE_DEFAULT_INSTANCE();

#include <ShiftIn.h>
ShiftIn<2> shift;





/* panicButton */
const int panicButton = 2;
int panicButtonRead = 0;
int pressedPanicButton = 0;


/* ledPins */
const int ledVerde = 3; // Green
const int ledRosso = 4; // Red
int ledOnCount = 0;

/* shift register */
int num;
int incoming;
int midiChannel;
int ccPot[2] = {0, 1};
int ccPotOld[2] = {0,0};
const int listaControlChange[11] = {7, 74, 71, 11, 1, 5, 73, 91, 93, 72, 10};

/* octave up and octave down */
const int up = 6;
const int down = 5;	        

int transp[2] = {0, 0};
int transpSlide[2] = {0, 0};
int pressedUp = 0;		  int pressedDown = 0;
int pressedSlideUp = 0; int pressedSlideDown = 0;
int transpUp;		        int transpDown;
int transpSlideUp;      int transpSlideDown;




/* rotPot and slidePot */
int cicliMidiCC[2] = {6, 6};
int jj[2] = {0, 0};

/* CC messages variables */
int ccValue[2];
int ccRead[2];
int ccValue_Old[2] = {0, 0};


/* Note range and tuning */
const int threshold = 998; // read values discarded above threshold

int lowestNote;             // first soft pot
int keyRange;               // number of keys on a single softpot
      
int pitchRange;
int tuning[2];              // semitone shift between soft pots
int minNote[2];
int maxNote[2];
int octaveShift;
int semitoneShift;


/* pitch bending */
int analogPitchRange;
float intervallo;
float pitchRangeFloat;
int pitchNota[2];
int pitchSent[2] = {-1,-1};
int pitchNotaOld[2];
int pitchPriority = 0;

/* Pitch stabilization */

int pitchTolerance;
float DEFAULT_pitchSnap;
float pitchSnap;
int snapOn[2] = {0,0};
float calcFloat[2];   
float calcInt[2];   
float decPart[2];


/* A3 = softpot1, A4 = softpot2, A1 = slidepot, A0 = rotpot */
const int analogPins[4] = {A3, A4, A1, A0};
float lettura[2];
int letturaInt[2];
float lettura_Sent[2];

float midiNoteFloat[2];
int midiNote[2];
int midiNote_Sent[2];
int midiNote_Old[2];
int sensorPressed[2] = {0, 0};

int count[2] = {0, 0};

int timePressed[2];


/* Pitch values to be applied when notes are snapped */
const int range12[25] = 
{0, 683, 1365, 2048, 2731, 3413, 4096, 4778,
5461, 6144, 6826, 7509, 8192, 8874, 9557,
10239, 10922, 11605, 12287, 12970, 13653,
14335, 15018, 15700, 16383};

const int range24[49] = 
{0, 341, 683, 1024, 1365, 1707, 2048, 2389,
2731, 3072, 3413, 3754, 4096, 4437, 4778,
5120, 5461, 5802, 6144, 6485, 6826, 7168,
7509, 7850, 8192, 8533, 8874, 9215, 9557,
9898, 10239, 10581, 10922, 11263, 11605,
11946, 12287, 12629, 12970, 13311, 13653,
13994, 14335, 14676, 15018, 15359, 15700,
16042, 16383};













void setup() {

  MIDI.begin(MIDI_CHANNEL_OMNI);
  Serial.begin(31250);


  /* Buttons */
  pinMode(panicButton, INPUT);
  pinMode(up, INPUT);
  pinMode(down, INPUT);


  pinMode(ledVerde, OUTPUT);
  /* HIGH = led off. LOW = led on. This is due to the led type used */
  digitalWrite(ledVerde, HIGH);
  pinMode(ledRosso, OUTPUT);
  digitalWrite(ledRosso, HIGH);

  

  /* Analog ports initialization */
  for (int ii = 0; ii <= 1; ii++) {
     pinMode(analogPins[ii], INPUT_PULLUP);
  }
  for (int ii = 2; ii <= 3; ii++) {
     pinMode(analogPins[ii], INPUT);
  }
  
  /* Read shift registers */
  shift.begin(8, 9, 11, 12);
  if(shift.update()) // read in all values. returns true if any button has changed
  incoming = readShiftReg();
  saveShiftRegRead(); // Assign incoming values to variables


  /* Softpot settings */
  lowestNote = 60;
  keyRange = 32;
  
  tuning[0] = 0;
  tuning[1] = 5;
  
  octaveShift = 0;
  octaveShift = octaveShift*12;
  semitoneShift = 0;

  /* Apply transopose if read by shift registers or defined */
  for (int ii = 0; ii <= 1; ii++) {
	  minNote[ii] = lowestNote + tuning[ii] + semitoneShift + octaveShift;
	  maxNote[ii] = minNote[ii] + keyRange;
  }
  

  if (bitRead(incoming,14)== 1) {
	  pitchRange = 24; //(+-semitones)
  } else {
	  pitchRange = 12; //(+-semitones)
  }
	
  pitchTolerance = (pitchRange-12)/12 * (50-100) + 100;
  DEFAULT_pitchSnap = 0.2;
	pitchSnap = DEFAULT_pitchSnap;
  intervallo = 16383 / (2*pitchRange);
  pitchRangeFloat = float(pitchRange);


  analogPitchRange = 1023/(keyRange)*pitchRange;


  /* Nothing pressed at the beginning */
  sensorPressed[0] = 0;
  sensorPressed[1] = 0;
  midiNote_Old[0] = 0;
  midiNote_Old[1] = 0;


}




void loop() {
	
	panic();
	readPots();
	transpose();
	noPressure();
	newPressure();
	firstRelease();
	prolongedRelease();
	assignPitchPriority();
	prolongedPressure();
	potsReadSendCC();

} 





int readShiftReg() {
  for(int i = 0; i < shift.getDataWidth(); i++){
    bitWrite(num, i, shift.state(i));
  }

  int incomingNumber = 0;
  for (int bitNumber = 8; bitNumber <= 15; bitNumber++) {
    bitWrite(incoming, incomingNumber, bitRead(num,bitNumber));
    incomingNumber++;
  }
  for (int bitNumber = 0; bitNumber <= 7; bitNumber++) {
    bitWrite(incoming, incomingNumber, bitRead(num,bitNumber));
    incomingNumber++;
  }
  return incoming;
}

void saveShiftRegRead() {

  bitWrite(midiChannel, 0, bitRead(incoming,0));
  bitWrite(midiChannel, 1, bitRead(incoming,1));
  bitWrite(midiChannel, 2, bitRead(incoming,2));
  bitWrite(midiChannel, 3, bitRead(incoming,3));

  bitWrite(ccPot[0], 0, bitRead(incoming,4));
  bitWrite(ccPot[0], 1, bitRead(incoming,5));
  bitWrite(ccPot[0], 2, bitRead(incoming,6));
  bitWrite(ccPot[0], 3, bitRead(incoming,7));

  bitWrite(ccPot[1], 0, bitRead(incoming,8));
  bitWrite(ccPot[1], 1, bitRead(incoming,9));
  bitWrite(ccPot[1], 2, bitRead(incoming,10));
  bitWrite(ccPot[1], 3, bitRead(incoming,11));

  /*
  bitRead(incoming,12) Not assigned, unused
  bitRead(incoming,13) Not assigned, unused
  bitRead(incoming,14) used to select pitch range
  bitRead(incoming,15) used to select if transpose acts on both softpots or just second one.
  */

}

void noteOn(int pitch, int velocity) {
  Serial.write(144 + midiChannel);        // Note on command
  Serial.write(pitch);                    // Note pitch
  Serial.write(velocity);                 // Note velocity 0-127
}

void pitchBend(byte lsb, byte msb) {
  Serial.write(224 + midiChannel);        // Pitch bend command
  Serial.write(lsb);                      // Pitch lsb
  Serial.write(msb);                      // Pitch msb
}

void pitchBendMessage(int pitchNota) {
  int shiftedValue = pitchNota << 1;
  byte lsb = lowByte(shiftedValue) >> 1;  // Pitch lsb
  byte msb = highByte(shiftedValue);      // Pitch msb
  pitchBend(lsb, msb);
}

void midiCC(int CCnumber, int ccValue) {
  Serial.write(176 + midiChannel);        // Control change command
  Serial.write(CCnumber);                 // CC number
  Serial.write(ccValue);                  // Volume 0-127
}

void transposeButtonsAction() {
  if (transpUp == HIGH && pressedUp == 0) {
    pressedUp = 1;

    if (bitRead(incoming, 15) == 0) {
      transp[0] = transp[0] + 12;
      transp[1] = transp[1] + 12;
    } else if (bitRead(incoming, 15) == 1) {
      transp[1] = transp[1] + 12;
    }
  }

  if (transpDown == HIGH && pressedDown == 0) {
    pressedDown = 1;
    if (bitRead(incoming, 15) == 0) {
      transp[0] = transp[0] - 12;
      transp[1] = transp[1] - 12;
    } else if (bitRead(incoming, 15) == 1) {
      transp[1] = transp[1] - 12;
    }
  }

  if (transpUp == LOW && pressedUp == 1) {
    pressedUp = 0;
  }

  if (transpDown == LOW && pressedDown == 1) {
    pressedDown = 0;
  }
}

void transposeSlideAction() {

  if (transpSlideUp == HIGH && pressedSlideUp == 0) {
    pressedSlideUp = 1;

    if (bitRead(incoming, 15) == 0) {
      transpSlide[0] = transpSlide[0] + 12;
      transpSlide[1] = transpSlide[1] + 12;
    } else if (bitRead(incoming, 15) == 1) {
      transpSlide[1] = transpSlide[1] + 12;
    }
  }

  if (transpSlideDown == HIGH && pressedSlideDown == 0) {
    pressedSlideDown = 1;
    if (bitRead(incoming, 15) == 0) {
      transpSlide[0] = transpSlide[0] - 12;
      transpSlide[1] = transpSlide[1] - 12;
    } else if (bitRead(incoming, 15) == 1) {
      transpSlide[1] = transpSlide[1] - 12;
    }
  }

  if (transpSlideUp == LOW && pressedSlideUp == 1) {
    if (bitRead(incoming, 15) == 0) {
      transpSlide[0] = transpSlide[0] - 12;
      transpSlide[1] = transpSlide[1] - 12;
    } else if (bitRead(incoming, 15) == 1) {
      transpSlide[1] = transpSlide[1] - 12;
    }
    pressedSlideUp = 0;
  }

  if (transpSlideDown == LOW && pressedSlideDown == 1) {
    if (bitRead(incoming, 15) == 0) {
      transpSlide[0] = transpSlide[0] + 12;
      transpSlide[1] = transpSlide[1] + 12;
    } else if (bitRead(incoming, 15) == 1) {
      transpSlide[1] = transpSlide[1] + 12;
    }
    pressedSlideDown = 0;
  }
}

void ledCtrl(int ledNum) {
  if (ledNum == 0) {
    digitalWrite(ledRosso, LOW);
    ledOnCount = 0;
  }
  if (ledNum == 1) {
    digitalWrite(ledVerde, LOW);
    ledOnCount = 0;
  }
  if (ledNum > 1 && ledOnCount < 3) {
    ledOnCount = ledOnCount + 1;
  }
  if (ledNum > 1 && ledOnCount >= 3) {
    digitalWrite(ledRosso, HIGH);
    digitalWrite(ledVerde, HIGH);
    ledOnCount = 0;
  }
}



void panic() {

  panicButtonRead = digitalRead(panicButton);
  if (panicButtonRead == HIGH && pressedPanicButton == 0) {

	  for (int panicChannel = 1; panicChannel <= 16; panicChannel++) {
		MIDI.sendControlChange(123,0,panicChannel);
	  }
	  pressedPanicButton = 1;
  } else {
	  pressedPanicButton = 0;
  }
}

void readPots() {
	for (int ii = 0; ii <= 1; ii++) {
    lettura[ii] = analogRead(analogPins[ii]);
    lettura[ii] = analogRead(analogPins[ii]);
	
      unsigned long timeStart = micros();
      while(micros() - timeStart < 5000){
        MIDI.read();
      }
    
    letturaInt[ii] = int(lettura[ii]);

    midiNoteFloat[ii] = (lettura[ii]-0)*(maxNote[ii]-minNote[ii])/(1023-0) + minNote[ii];
    midiNote[ii] = int(midiNoteFloat[ii]) + transp[ii] + transpSlide[ii];
  }

  MIDI.read();
}

void transpose() {
  transpUp = digitalRead(up);
  transpDown = digitalRead(down);

  shift.begin(8, 9, 11, 12);
  if(shift.update())
  incoming = readShiftReg();

  transposeButtonsAction();
  MIDI.read();
}

void noPressure() {
	for (int ii = 0; ii <= 1; ii++) {

    if (letturaInt[ii] >= threshold ) {
      ledCtrl(23);
      sensorPressed[ii] = 0;
      timePressed[ii] = 0;
    }
	MIDI.read();
  }
}

void newPressure() {
	for (int ii = 0; ii <= 1; ii++) {
    if(letturaInt[ii]<=threshold && sensorPressed[ii]==0 && midiNote[ii]!=midiNote_Old[ii]){

      ledCtrl(1);

      pitchNota[ii] = 8192;
      pitchBendMessage(pitchNota[ii]);

      noteOn(midiNote[ii], 0x7F);

      sensorPressed[ii] = 1;
  	  count[ii] = 1;

      timePressed[ii] = 1;
      
      midiNote_Old[ii] = midiNote[ii];
      midiNote_Sent[ii] = midiNote[ii];
      lettura_Sent[ii] = lettura[ii];

      int kk;
      if (ii == 0) {kk = 1;} else if (ii == 1) {kk = 0;}
      
      if (timePressed[kk] >= 1 && timePressed[ii] < timePressed[kk]) {
        pitchPriority = ii + 1;
      }else if (timePressed[kk] == 0) {
        pitchPriority = ii + 1;
      }
      
      MIDI.read();
    }
  }
}

void firstRelease() {
	for (int ii = 0; ii <= 1; ii++) {
    if ((letturaInt[ii] >= threshold) && count[ii] == 1) {

      ledCtrl(0);
      noteOn(midiNote_Old[ii], 0x00);

      sensorPressed[ii] = 0;
      midiNote_Old[ii] = midiNote[ii];
      count[ii] = count[ii] + 1;
  
      MIDI.read();
    }
  }
}

void prolongedRelease() {
	for (int ii = 0; ii <= 1; ii++) {
    if (letturaInt[ii] >= threshold && count[ii] >=2) {
      ledCtrl(23);
      
      sensorPressed[ii] = 0;
      count[ii] = 0;
      timePressed[ii] = 0;
      
      MIDI.read();   
    }
  }
}

void assignPitchPriority() {

  if (timePressed[1] == 0 && sensorPressed[0] == 1 && timePressed[0] >= 0) {
    pitchPriority = 1;
  } else if (timePressed[0] == 0 && sensorPressed[1] == 1 && timePressed[1] >= 0) {
    pitchPriority = 2;
  }
}

void prolongedPressure() {
	for (int ii = 0; ii <= 1; ii++) {
    if (letturaInt[ii] <= threshold && sensorPressed[ii] == 1 && pitchPriority == ii+1) {

      ledCtrl(23);

      if (lettura[ii] <= lettura_Sent[ii] - analogPitchRange) {
        lettura[ii] = lettura_Sent[ii] - analogPitchRange + 1;
      }
      if (lettura[ii] >= lettura_Sent[ii] + analogPitchRange) {
        lettura[ii] = lettura_Sent[ii] + analogPitchRange + 1;
      }

      pitchNota[ii] = map(lettura[ii], lettura_Sent[ii] - analogPitchRange,
                                  lettura_Sent[ii] + analogPitchRange, 0,16383);
      
			/* Pitch stabilization */
      pitchStabilization(ii);

      /* Send stabilized pitch */
      if (pitchSent[ii] != pitchNota[ii]) {
        pitchBendMessage(pitchNota[ii]);
        pitchSent[ii] = pitchNota[ii];
      }
      
      timePressed[ii] = timePressed[ii] + 1;
      
      MIDI.read();
    }
  }
}

void pitchStabilization(int iii) {

      if ((pitchNota[iii] >= 8192 - pitchTolerance) && 
                                   (pitchNota[iii] <= 8192 + pitchTolerance)) {
       pitchNota[iii] = 8192;
      }

      calcFloat[iii] = pitchNota[iii]/intervallo;
      calcInt[iii] = (int)calcFloat[iii];
      decPart[iii] = calcFloat[iii] - calcInt[iii];
		
	  /* Snap pitch towards up (1), and down (2) */
	  /* (1) */ 
      if (decPart[iii] <= pitchSnap){
        snapOn[iii] = 0;
        if (bitRead(incoming,14) == 0) {
          pitchNota[iii] = range12[(int)calcInt[iii]];
        } else {
          pitchNota[iii] = range24[(int)calcInt[iii]];
        }
        pitchNotaOld[iii] = pitchNota[iii];
        
      } else {
        snapOn[iii] = snapOn[iii] + 1;
        if (snapOn[iii] <= 2 && abs(pitchNota[iii]-pitchNotaOld[iii])> 15) {
          pitchNota[iii] = pitchNotaOld[iii];
        }
      }
      
	  /* (2) */
      if (decPart[iii] >= (1 - pitchSnap)){
        snapOn[iii] = 0;
        if (bitRead(incoming,14) == 0) {
          pitchNota[iii] = range12[(int)calcInt[iii]+1];
        } else {
          pitchNota[iii] = range24[(int)calcInt[iii]+1];
        }
        pitchNotaOld[iii] = pitchNota[iii];
       
      } else {
        snapOn[iii] = snapOn[iii] + 1;
        if (snapOn[iii] <= 2 && abs(pitchNota[iii]-pitchNotaOld[iii])> 15) {
          pitchNota[iii] = pitchNotaOld[iii];
        }
      }

}

void potsReadSendCC() {
	for (int ii = 0; ii <= 1; ii++) { 

		if (ccPot[ii] == 13) {
			cicliMidiCC[ii] = 7;
		} else {
			cicliMidiCC[ii] = 7;
		}
 
    if ((jj[ii] % (cicliMidiCC[ii] - ii)) == 0) {
		if (ii == 0) {
			unsigned long timeStart = micros();
			while(micros() - timeStart < 4000){
			  MIDI.read();
			}
        }
      
      ccRead[ii] = analogRead(analogPins[ii+2]);

      jj[ii] = jj[ii] + 1;
      if (jj[ii] == cicliMidiCC[ii] - ii) { jj[ii] = 0; }
      MIDI.read();

      ccValue[ii] = map(ccRead[ii], 0, 1023, 0, 127);

      if (ccValue[ii] != ccValue_Old[ii] && ccPot[ii] != 12 && ccPot[ii] != 13){
          midiCC(listaControlChange[ccPot[ii]], ccValue[ii]);
      } else if (ccPot[ii] == 12) {

        if (ccRead[ii] <= 100) {
            transpSlideDown = HIGH;

        } else if (ccRead[ii] >= 800) {
            transpSlideUp = HIGH;

        } else {
            transpSlideDown = LOW;
            transpSlideUp = LOW;
        }
          
        transposeSlideAction();
      } else if (ccPot[ii] == 13) {
				/* Control pitch snap with rotPot */
				pitchSnap = (ccRead[ii])*0.4/1023 + 0.2;
				ccPotOld[ii] = 13;
			}
      ccValue_Old[ii] = ccValue[ii];
    } else {
      jj[ii] = jj[ii] + 1;

      if (jj[ii] == 2*cicliMidiCC[ii] - ii) { jj[ii] = 0; }
    }
		
		if (ccPotOld[ii] == 13 && ccPot[ii] != 13) {
			pitchSnap = DEFAULT_pitchSnap;
			ccPotOld[ii] = ccPot[ii];
		}
		
	}
 
}

#Python 3.6
import numpy as np

# Pitch range value, interpreted, as in synthesizers, as +- number of semitones
pitchRange = 12

# Generate the array containing all the pitch bend values corresponding to
# exact notes for the given pitch range.
range12 = np.round(np.arange(-8192, 8192, 16383 / 2 / pitchRange) + 8192)

# Name of the variable containing exact notes pitch bend value in the
# Arduino code
varName = 'range' + str(int(pitchRange)) +\
          '[' + str(int(2 * pitchRange + 1)) + ']'

# Name of the txt file
fileName = 'pitchValues' + str(int(pitchRange)) + '.txt'

# Write the txt file with Arduino syntax, ready to be copy-pasted in the
# IDE
with open(fileName, 'w') as f:
    f.write('const int ' + varName + ' = \n')
    f.write('{')
    for pitchValue in range12[0:-1]:
        f.write(str(int(pitchValue)))
        f.write(', ')
    f.write(str(int(range12[-1])))
    f.write('};')

Credits

andreagregorini

2 projects • 3 followers

Mechanical engineer based in Milan. Free time musician and keyboard player for The Cinema Show prog band. Photography enthusiast.

ARKeytar - Arduino Based MIDI Controller Keytar

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

The story

The Arduino Circuitry and Code Logic

The Maple Body and Neck

The Result

Controlling virtual and physical instruments

ARKeytar parts

Schematics

Soft pots

MIDI in and MIDI out circuits

Shift registers

Code

ARKeytar v5.21

Pitch Bend Tables

Credits

andreagregorini

Comments

Embed the widget on your own site

ARKeytar - Arduino Based MIDI Controller Keytar

ARKeytar - Arduino Based MIDI Controller Keytar

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

The story

The Arduino Circuitry and Code Logic

The Maple Body and Neck

The Result

Controlling virtual and physical instruments

ARKeytar parts

Schematics

Soft pots

MIDI in and MIDI out circuits

Shift registers

Code

ARKeytar v5.21

Pitch Bend Tables

Credits

andreagregorini

Comments

Related channels and tags