Forum Rule: Always post complete source code & details to reproduce any issue!
Results 1 to 10 of 10

Thread: [queued] Easy (lazy) Chord Player

  1. #1

    [queued] Easy (lazy) Chord Player

    Hello,

    I am happy to present a MIDI controller I have designed to play chords progressions. It's fun to play and very inspirational.
    You can play chords and bass lines together. The chords choice is big. There are 20 different chords per note. Chord structures are stored in a user bank so you can create and save your own very special sophisticated chords if needed.
    Here is a brief presentation of the main features :


    And a small demo when hooked with ableton Live :


    Feedback welcome !
    Emmanuel

  2. #2
    Here are a few pics :
    Click image for larger version. 

Name:	Chhord-Player1.jpg 
Views:	14 
Size:	165.4 KB 
ID:	19461Click image for larger version. 

Name:	Chhord-Player2.jpg 
Views:	13 
Size:	222.6 KB 
ID:	19462

  3. #3
    Senior Member+ defragster's Avatar
    Join Date
    Feb 2015
    Posts
    11,571
    Cool.
    What's up with all the buttons and hardware?

  4. #4
    Hello,
    The buttons and pots are basic MIDI controls you can map to your DAW.
    The hardware ICs are generic multiplexers. They read the 168 keys plus the MIDI controls and commands. MUXs are easy to deal with. I thought it would be a hassle, but it was in fact the easy part.
    For me, the hardest part was to deal with the logic when you press multiple keys at the same time. You have to track which notes have been triggered, and how many times. Otherwise you get "stuck notes" when yo release the keys.
    Emmanuel

  5. #5
    Senior Member+ defragster's Avatar
    Join Date
    Feb 2015
    Posts
    11,571
    The 14 buttons per note - are they touch sense? Nice uniform layout - just wondering what is under that colored label system.

  6. #6
    All keys are touch sensitive. It's made with Velostat sheets. This material is very cheap and the result is surprisingly accurate. Each key work as a shunt mode FSR :
    https://butlertechnologies.com/shunt-mode-vs-thru-mode/
    The result is ultra thin, very reactive easier to read compare to piezzo sensors.

  7. #7
    Senior Member+ defragster's Avatar
    Join Date
    Feb 2015
    Posts
    11,571
    Very cool. Looks like a lot of nice work and features packed in that setup

  8. #8
    Administrator Paul's Avatar
    Join Date
    Oct 2012
    Posts
    369
    Is any more info available about the hardware and code used?

  9. #9
    Hi Paul,
    Sure ! I can write a description about it.
    Basically, the hardware is made with 128 DIY FSRs. I make them with Velostat.
    The code detects when a FSR is hit, analyse the force, and transmit a midi message.
    All the chords formulas are store in arrays.
    If you think this project might interest some people, I would be happy to give details.

    Have you seen this other project :
    https://youtu.be/N79Hcg-cOfI
    It's really fun to play with.
    Emmanuel

  10. #10
    Hi Paul,
    Hi musicians,

    Here is a description of my chord player.

    I am musician and composer. I play brass instruments and guitar. When composing, I often start with layering some chord progressions to find ideas. Since I don't play keyboards, it's difficult and frustrating. So I decided to build an MIDI instrument to help with playing complex and rich chord progressions. There are plenty of third-party plugins or devices, but they all have limitations : the choice of chords is poor, and a lot of them require to choose a *root key* which is a big constrain.
    With the my prototype, you can play ready-made chords with one finger. With the right hand, you can play chords and with the left hand you can play a bass line. The choices of chords is large and goes from basic triads to complex jazz extended chords.

    THE LAYOUT :
    Click image for larger version. 

Name:	FIG 1.jpg 
Views:	3 
Size:	198.0 KB 
ID:	20373
    For each root note of the scale, there is a choice of 10 ready-made chords, plus 4 basses. The root notes are organized following the 5th cycle which is more logical when playing chord progressions. A pedal add an alternative choice of 10 chords. Here are the basic functionalities :
    - a choice of 20 chord structures per note. From triads to altered chord, suspended, diminished, semi diminished... and "custom" chords.
    - 4 basses per note. Root, Maj third, min third, b9.
    - 168 force sensitives pads keyboard
    - separate MIDI channel for basses and chords
    - various knobs to control octaves, volume, chord inversions, velocity range, and a basic arpeggiator
    - 12 pots + 12 switches (toggle or momentary) assigned to MIDI CC for controlling software.
    - sustain pedal, pitch and mod wheel
    - a bank to store "styles". The styles enhance some kinds of chord structure. For instance, the "jazz style" will emphase characteristic chord extensions to give a jazz flavor to the progression. Song writer style will emphase for instance the 9th with the major and minor chords...

    THE HARDWARE
    To keep the budget low, I have made my own force sensitive pads. I have tested many assemblies and material. I have the best result with Velostat sheets. It is very cheap and easy to cut and glue. Here my "recipe" :
    Click image for larger version. 

Name:	FIG 2.jpg 
Views:	3 
Size:	132.6 KB 
ID:	20375
    1 : PCB
    2 : 1/10 millimeter plastic spacer
    3 : Velostat
    4 : printed plastic sheet

    Result is quite OK. I have reliable and even response. Velostat is a delicate material. If you foil it or get it a bit dirty (finger prints), the readings are uneven.

    THE CODE
    I use 12 MUXs to read all the pads and knobs. I was worried about latency, but it is really fast. Absolute "real time" feeling. Code is simple, nothing new.
    "mux_value[n][i]" array stores pads readings. First index specifies the MUX number, second index specifies the channel number. "channel[][] " array stores channels adresses.
    I know this could be simpler, but that was my first time dealing with MUXs...

    void MuxRead() {
    for (short i = 0; i < channels_nb; i++) {
    digitalWrite(s0, channel[i][0]);
    digitalWrite(s1, channel[i][1]);
    digitalWrite(s2, channel[i][2]);
    digitalWrite(s3, channel[i][3]);

    mux_value[0][i] = analogRead(A15); //F# (root notes)
    mux_value[1][i] = analogRead(A16); //B
    mux_value[2][i] = analogRead(A17); //E
    mux_value[3][i] = analogRead(A18); //A
    mux_value[4][i] = analogRead(A19); //D
    mux_value[5][i] = analogRead(A20); //G
    mux_value[6][i] = analogRead(A21); //C
    mux_value[7][i] = analogRead(A22); //F
    mux_value[8][i] = analogRead(A6); //Bb
    mux_value[9][i] = analogRead(A7); //Eb
    mux_value[10][i] = analogRead(A8); //Ab
    mux_value[11][i] = analogRead(A9); //Db
    }
    }


    Then a function detect a "hit", and trigger a chord. Here is the idea :

    //cycling through all MUXs readings :
    for (short n = 0; n < mux_nb; n ++) {

    //pads readings
    for (short i = 0; i < pads_nb; i ++)
    {
    if ( mux_value[n][i] > (threshold) && hit[n][i] == 0) {
    hit[n][i] = 1;
    playChord(n,i);
    }

    if ( mux_value[n][i] < threshold && hit[n][i] == 1) {
    hit[n][i] = 0;
    muteChord(n,i);
    }
    }


    Each chord structure is stored in an array, for instance a MAJ7 chord will be :
    MAJ7 [] = {0, 4 , 7, 11};
    where numbers represent intervals from the root note 0.

    The playChord(n,i) function construct a MIDI message. The indexes n and i of "mux_value[n][i]" indicates with chord formula to call. The value of "mux_value[n][i]" gives the velocity (after some basic conditioning o fit the 0-127 MIDI range).

    Hope this article will give some ideas !
    I will be happy to answer questions if I can (I am quite new to coding).
    Have a look at may second project here, which really fun to play with : https://youtu.be/N79Hcg-cOfI

    Emmanuel

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •