14-Bit MIDI input

I own a Faderfox UC4 and an EC4. Their encoders can be set to 14-Bit Mode which sends two control change commands (MSB/LSB) to get values 0 to 16383 instead only 0 to 127.

While 127 steps are sufficient for parameters like volume, pan or mix, there are a lot of parameters that sound choppy or simply bad. 14-Bit resolution would solve that. The last thing I tried was the Offset of the FlexiSampler in Scratch Mode. It is impossible to precisely position the cursor and it sounds choppy. But even basic parameters like the Pitch, when changed slowly, are unusable.

Are there any plans to implement this?

It's crazy that even AUM seems not to support it.

So this would be the highest priority on my wishlist. This ... and MIDI feedback ... :-)


  • edited December 2022

    You can more or less implement this with the existing modules. You can map one drambo knob to the MSB and one knob to the LSB. Then use some modules to scale the LSB to be 1/127th and the MSB to be 126/127ths. Add the two signals together and you can use the output to modulate.

    I have an EC4 and do this. I'm not by my iPad at the moment but I can upload my module for this later.

    It would be nice to have native support though, would be a lot easier.

  • You may want to adjust your scaling of the combined input slightly. Here's my derivation.

    Drambo CC scaling (a and b are the internal CV):

    a = MSB / 127 ; b = LSB / 127

    Reconstruct 14-bit input value X (128 is 7-bit shift):

    X = 128 * MSB + LSB  = 127 * ( 128*a + b )

    Note that 127*129 = 16383 = 2^14 - 1. This is max value for X. Scale X to 0..1:

    y = X / ( 127*129 ) = ( 128*a + b ) / 129

    So, the scale factors are 128/129 for MSB and 1/129 for LSB. Since Drambo uses floating point, you can actually evaluate it directly as (128*a+b)/129.

  • Actually, this reduces to

    y = a + ( b - a ) / 129

    which is easy to implement. It emphasizes the relatively insignificant contribution of the LSB.

  • edited December 2022

    Thanks for the hints.

    I have now built a processor rack that works perfectly.

  • edited December 2022

    Ok, by using fractions it is even simpler :-)

  • Here's my version of your rack, using the formula I posted above. If you work it out, you'll see that 129 is the correct divisor. You can actually do the scale and add with the Scale Offset module, but that makes the 1/129 factor less obvious.

  • Mmmhh...

    Why is 129 the divisor?

    Both MIDI values are from 0 to 127. The knobs deliver 0.0 - 1.0. Therefore 1.0 represents 127. When I scale the MSB to this and keep the LSB, I have 127.0 + 1.0 = 128.0. What have I missed?

    The Offset at the end of my rack is optional to use for target values that are not from 0.0 - 1.0. For example, the FlexiSampler: Its "Offset" Parameter works directly, but when I target the "Pitch" parameter (-24.0 to 24.0 semitones) I have to set my optional Offset parameter to -0.5 to control its full range. Therefore I added the Offset parameter to reflect that.

    As I wrote this I re-testet my optional Offset parameter and it didn't work correctly on the "Speed" parameter. So I replaced it with a Scale + offset module, which should have been obvious. And called it "Target Range".

    So, in regard of the FlexiSampler, the "Target Range" settings seem to be

    • "Pitch" - Offset: -0.5, Range: 0.5 (don't know why, but sounded correct)
    • "Speed" - Offset: -1.0, Range: 2.0 (Playback stops between 63/64 MIDI value as expected and both ends sound correct)
    • "Offset" - Offset: 0.0, Range: 1.0 (correctly positions the cursor from start to finish)

  • @HarlekinX . Please look at my derivation above, https://forum.beepstreet.com/discussion/comment/42632/#Comment_42632. We need to reconstruct the original 14-bit value from the two scaled CVs, then convert that value to range 0..1.

  • I added the "Target Range" module to your rack version and tested both, side by side.

    Both rack versions seem to deliver the exact same results. :-)

    This shows two different approaches to reach a target. Mine seems more straight forward. Yours is more difficult to understand at first but probably some nanoseconds faster because of less scaling.

    I will stay with my version until the time comes that this functionality will be integrated in Drambo. Hey, beloved Devs, even AUM does not have it. You could be first :-)

    Good work 👍 @uncleDave

    This was fun

  • edited January 2

    For my EC4 setup, I have created two separate groups with the same parameters. One sends the value as 7-bit midi, while the other sends 14-bit midi. This is because 14-bit midi on the EC4 is really slow, even with acceleration on. So with my solution you can switch between two groups to get fast turning or slow turning.

    The problem I had with this approach and my previous Drambo 14-bit implementation is that the fast/7-bit EC4 group couldn't hit the full range of values because it just sent the MSB. If the LSB was above .5 you maybe couldn't hit zero, or if LSB wasn't high enough you couldn't hit max.

    To solve this, I changed my rack to have some "dead space" at the beginning / end of the full range. This means if the MSB knob is at 0 or 1, the LSB will not change the value. But it means that no matter what the MSB can hit the full range. What you can't see here is that the MSB rack knobs have their ranges from -0.0078125 (-1/127) to 1 (127/127), and the LSBs are from 0 (0/127) to 0.0078125 (1/127). Note that in this screenshot I am mapping 4 EC4 knobs to control a complex LFO.

    Anyways, I may be the only person who cares about this, but I found it very useful for my specific use case :) .

    p.s. I brought up to the creator of Faderfox that it would be awesome there was an option to make knobs faster if they are turned while clicked down. This is how Elektron does it and it works great. I got back a pretty standard "I'll look into it with the next release" answer, which is understandable. Not holding my breath but yea :)

  • @uncleDave @quartzite

    Can this method be used to send both Program and Bank Changes

    I have a JV1010 that will accept MSB for Bank changes and though I’m currently

    using Mozaic to assign the sounds I would prefer it if I could have some thing native to dRambo.

    Here’s the JV1010 manual.


  • Its kind of the opposite of 14 bit midi input. But you should just be able to send the Bank Select messages (CC 0 followed by CC 32) and then the Program Change message. Drambo sends midi messages in the order of the modules on the screen, so as long as you put them in the right order it should work. You might need to put a midi delay on the later messages if the jv-1010 can't handle multiple messages coming simultaneously.

  • Thanks for this I'll give it a try and see what happens.

  • edited January 14

    For my setup, I use my EC-4 for most parameter controls, but I use TouchOSC (in Slide Over mode) for volume and fx send control. I realized that with scripting, TouchOSC can send 14-bit midi to Drambo. The finer grain control is great.

    With a fader that's half the height of the screen, the resolution is really only about 500 discrete values, but I found it worth it.

    If anyone goes down this path, I can pass along more info.

  • Good to know.

    On my part I’ve got something half baked at the moment that

    can Bank and Patch select for the JV series Roland modules.

    It needs fine tuning in regards to the scaling but it does the do.

    I have 16 of these mapped to the LC XL for control of my JV-1010

    and it can easily be modified for other sound sources that use MSB/LSB messages etc.

Sign In or Register to comment.