Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

Sign In with Twitter

Simple DIY 4 fader controller Livid Elements + Brain Jr

Hi guys,


I'm completely new to DIY electronics but I'm looking to make myself a simple yet compact midi controller with four faders. I cam across this livid elements 4k4 component on amazon that looks perfect. https://www.amazon.co.uk/Livid-Instruments-°F-Elements-Module/dp/B00CWEO5JO

Will this combine with the Brain Jr to give me what I need?  Are there any other components that I need? 

I found the livid wiki pages for the Elements and Brain Jr. I can see that the elements components use 10 pin ribbon cables to connect to the brain patchboard. I would rather not have to buy the large patchboard both because if it's size and the price. Hence why I'm considering the Brain Jr which is cheaper and smaller. As far as I can tell (and I'm a total newb) the Brain Jr doesn't have 10 pin inputs but I presume it shouldn't be too challenging to rewire it with jumper cables or something. 

I would really appreciate any advice or assurance before I jump in and start buying parts. 

Thanks! 
Sharma

Comments

  • edited July 5

    Hi Sharma,

    You would also need an Omni Breakout Shield for BrainJr.
    Then it connects with a 2x5 (0.1") ribbon cable. 

    Keep in mind that we do not have stock of BrainJr or the Omni Breakout Shield.

  • Hi Moon, thanks for the advice. Do you have any idea if/when Livid will stock these products again? Alternatively, how complex would it be to replicate this using an Arduino or Teensy Board or something. 


    Many thanks, 
    Sharma 
  • edited July 18

    One more thing, is there some documentation somewhere that would tell me how the 2x5 pin header is wired for 4k4f component? I've not been able to find it on the Livid Wiki.  

    Thanks!

  • edited July 18

    Ok, I think I might be slowly wrapping my head round this.

    I've found this info on the Omni RGB wiki page, that may have answered my last question. 

    "All analog headers consist of a common ground(Gnd) and power(VCC) that all pots share on that header, as well as an individual “wiper” pin for each specific potentiometer on that header."


    And: 

    Slide1-4Pot13-16 (potentiometer)
    pin1 - Gnd
    pin2 - VCC
    pin3 - wiper1
    pin4 - wiper2
    pin5 - wiper3
    pin6 - wiper4
    pin7 - wiper5
    pin8 - wiper6
    pin9 - wiper7
    pin10-wiper8


  • Hey Moon, 


    Just wanted to let you know that I've figured it all out now and I've got it working with a Teensy board. The wiring was fairly straight forward once I found that information. The code a little complex but I got there in the end. Only thing that was odd is that the faders are inverted. No idea if this is intentional or accidental. 

    Anyway, thanks for your help!
  • Hi Sharma, want to share your Teensy code?

  • edited July 31

    Sure. I'd don't have much experience in programming (just a little bit that I've picked up) so there may well be a more elegant way of doing it. My starting point was this guys tutorial: http://djtechtools.com/2015/08/25/how-to-make-your-own-diy-midi-controller/ ;

    However I further modified the code in a few ways. 


    First I wanted independent control over each fader and know so that I could specify which CC each controlled. The guy in the tutorial define the CCs automatically using an array so they just ended up with consecutive values 0 - 7. I defined my CCs as global variables and then apply them in each program loop. 

    Secondly I also needed to invert the output values for the faders but not for the rotary knobs so the faders needed slightly different code. 

    As a result my code looks a lot longer and it requires that I define a lot of variables but it is effectively the same program that the guy used, just repeated 8 times. 

    Also I set a normalisation value (global variable: norm) to define the smallest value that the controller would send to the computer. In the end I set it as 2 (that's midi value 2). I had it as 1 at first but was finding sometimes the current would still fluctuate but magnitudes greater than 1 and as a result send midi date when I hadn't touched the controller. 

    The lines 'Serial.print("Fad 04: ");' and 'Serial.println(fad04Val);' are not necessary to run the controller. They just print text to the console so I can see what's happening and debug. 


  • edited July 31

    Anyway, here's my code. I'm no expert but happy to share my reasoning. Have to split this across a few posts due to the character limit. 

    PART 01

    int midiChannel = 1; //Midi chanell used for entier unit
    int norm = 2; // Used to stop slight fluctuations in the cuircuit sending controler data
    int delayTime = 5;

    // CC Assignment
    int pot01CC = 20;
    int pot02CC = 21; 
    int pot03CC = 22; 
    int pot04CC = 23; 

    int fad01CC = 1;
    int fad02CC = 11;
    int fad03CC = 24;
    int fad04CC = 25;

    // Declare variabled to assign pin numbers 
    int pot01=0; 
    int pot02=1;
    int pot03=2;
    int pot04=3;
    int fad01=4;
    int fad02=5;
    int fad03=6;
    int fad04=7;

    // Decalre variables to use for comparing sensor values
    int pot01Val=0;
    int pot01ValAfter=0;
    int pot02Val=0;
    int pot02ValAfter=0;
    int pot03Val=0;
    int pot03ValAfter=0;
    int pot04Val=0;
    int pot04ValAfter=0;
    int fad01Val=0;
    int fad01ValAfter=0;
    int fad02Val=0;
    int fad02ValAfter=0;
    int fad03Val=0;
    int fad03ValAfter=0;
    int fad04Val=0;
    int fad04ValAfter=0;

    void setup() {
      Serial.begin(31250); // Set to MIDI rate
      // Initiate pins for each sensor and set pinmode to INPUT_PULLUP which uses the built in resistors. 
      pinMode(pot01, INPUT_PULLUP);
      pinMode(pot02, INPUT_PULLUP);
      pinMode(pot03, INPUT_PULLUP);
      pinMode(pot04, INPUT_PULLUP);
      pinMode(fad01, INPUT_PULLUP);
      pinMode(fad02, INPUT_PULLUP);
      pinMode(fad03, INPUT_PULLUP);
      pinMode(fad04, INPUT_PULLUP);
    } // End void setup

  • edited July 31

    PART 2


    void loop() {
      //Pot 01
      pot01Val = analogRead(pot01)/8; //Read Pot01 divide by 8 to get MIDI values
      if (abs(pot01Val - pot01ValAfter) > norm){ // Compare intial value to new value to see if there has been a change
        usbMIDI.sendControlChange(pot01CC, pot01Val, midiChannel); // send the MIDI - (CC, CC value, MIDI Channel)
        Serial.print("Pot 01: "); // Just used to print a message to the console for debugging
        Serial.println(pot01Val); // Just used to print a message to the console for debugging
        pot01ValAfter = pot01Val; // Set intial value to new value for next comparisom
        delay(delayTime);
        }
        
       // Pot 02
       pot02Val = analogRead(pot02)/8;
       if (abs(pot02Val - pot02ValAfter) > norm){
        usbMIDI.sendControlChange(pot02CC, pot02Val, midiChannel);
        Serial.print("Pot 02: ");
        Serial.println(pot02Val);
        pot02ValAfter = pot02Val;
        delay(delayTime);
        }

       // Pot 03
       pot03Val = analogRead(pot03)/8;
       if (abs(pot03Val - pot03ValAfter) > norm){
        usbMIDI.sendControlChange(pot03CC, pot03Val, midiChannel);
        Serial.print("Pot 03: ");
        Serial.println(pot03Val);
        pot03ValAfter = pot03Val;
        delay(delayTime);
        }

        // Pot 04
       pot04Val = analogRead(pot04)/8;
       if (abs(pot04Val - pot04ValAfter) > norm){
        usbMIDI.sendControlChange(pot04CC, pot04Val, midiChannel);
        Serial.print("Pot 04: ");
        Serial.println(pot04Val);
        pot04ValAfter = pot04Val;
        delay(delayTime);
        }

        // Fad 01
       fad01Val = 127-(analogRead(fad01)/8); // For some reason the Livid faders are inverted. This reverses it 
       if (abs(fad01Val - fad01ValAfter) > norm){
        usbMIDI.sendControlChange(fad01CC, fad01Val, midiChannel);
        Serial.print("Fad 01: ");
        Serial.println(fad01Val);
        fad01ValAfter = fad01Val;
        delay(delayTime);
        }

        // Fad 02
       fad02Val = 127-(analogRead(fad02)/8);
       if (abs(fad02Val - fad02ValAfter) > norm){
        usbMIDI.sendControlChange(fad02CC, fad02Val, midiChannel);
        Serial.print("Fad 02: ");
        Serial.println(fad02Val);
        fad02ValAfter = fad02Val;
        delay(delayTime);
        }

        // Fad 03
       fad03Val = 127-(analogRead(fad03)/8);
       if (abs(fad03Val - fad03ValAfter) > norm){
        usbMIDI.sendControlChange(fad03CC, fad03Val, midiChannel);
        Serial.print("Fad 03: ");
        Serial.println(fad03Val);
        fad03ValAfter = fad03Val;
        delay(delayTime);
        }

        // Fad 04
       fad04Val = 127-(analogRead(fad04)/8);
       if (abs(fad04Val - fad04ValAfter) > norm){
        usbMIDI.sendControlChange(fad04CC, fad04Val, midiChannel);
        Serial.print("Fad 04: ");
        Serial.println(fad04Val);
        fad04ValAfter = fad04Val;
        delay(delayTime);
        }
       
    } // End void loop

Sign In or Register to comment.