KnobConnector: Control any plugin with your E1 in REAPER 7

Instruments
,
23

Suggestions for Improving Knob Connector Workflow with Electra One in REAPER

Hi there,

First of all, thank you so much for creating Knob Connector — it’s a brilliant concept! I use the Electra One controller to control VST plugins in REAPER, and it genuinely helps me mix by ear rather than by eye. This has taken my sound quality to a new level.

The E1 has so much power under the hood — and I’d love to unlock more of it in my current workflow with Knob Connector. I’ve gathered some thoughts and ideas that I believe could further improve the experience and workflow inside REAPER:

1. Reloading Plugin Maps Without Restarting REAPER
When I edit a custom Plugin Map, I currently need to restart REAPER for the changes to take effect. Maybe I’m missing something — but with my FaderPort, I could use a “Refresh all surfaces” script to reload control surfaces without restarting the DAW.

2. Screen Layout Optimization
I really like the module/submodule concept. However, in most cases, a third of the screen remains unused, while I run out of encoder space when customizing Plugin Maps. It would be ideal to make use of the middle section for additional controls. The module and submodule display could be moved to the top section, which already supports color coding — so everything would stay organized and intuitive.

3. Pad toggle support in Plugin Maps
It would be great to use the touchscreen to control two-state plugin functions, such as bypassing FX or linking stereo channels in compressors. These actions are ideal for toggle-style pads, and using them on the touchscreen would make plugin control more direct and intuitive.

4. Run REAPER actions from Electra One
When mixing, I often use track templates and common FX chains.
It would be great if Electra could display folders like DYN, EQ, TEMPL, etc. — and tapping on an item inside would trigger REAPER scripts or actions, even if no FX window is open.

5. Custom Channel Strip Mode
A mode designed for controlling multiple FX across a single track, using all three screen zones of the E1.
This could include a helper script to auto-generate a Plugin Map for all FX on the track, allowing for quick layout and mapping inside the web editor.

Thanks again for your incredible work — and for being so open to feedback. I’d be more than happy to test or help develop any of these features further.

Best regards,
Sergey Elt

1 Like
24

Thanks a lot for the detailed feedback, much appreciated.

I’m planning to either expose an action that reloads the maps or reinitializes the plugin.

In the meantime, you can open KnobConnectors config dialog (via Preferences->Plug-Ins->Control/OSC/web->KnobConnector (double click or press Edit) ) and then click on “OK”. The moment you do that in any of Reaper’s Control Surface configuration dialogs, Reaper should reinitialize all (or just that specific) plugin. This is how I edit maps at the moment myself: I just keep the preferences window open and whenever I want to reload a map, I hit “Edit” in the Preferences window and then “OK” in the configuration dialog.

The module/submodule concept came up because I wanted something that works with very complex synth plugins like VCV Rack or Reason Rack Plugin. Those can have 1000 to 3500 parameters and making those explorable and navigable for the E1 for my sound design work was my initial goal since most control surfaces I know are optimized for plugins with mabye 30 parameters (great for mixing or performances) but struggle considerably to handle more complex plugins.

That being said, I think it would be awesome if users could make their own layouts and it’s something I’ve been thinking about lately. Depending on how I want this to happen (for instance, Reaper telling the E1 how to arrange the layout/controls, which would be the most flexible approach), there’s some functionality missing for that in the E1 OS.

I agree, but it’s due to a current limitation in the E1 OS (the same limitation I mentioned in the paragraph above).

Triggering arbitrary Reaper actions from the E1 is also something that crossed my mind when I thought about the custom layout feature. Good to know you’d find it useful! I’ve added it to my notes for future features.

This is also something that I thought about, partly because of similar feedback from other users, partly because I wanted to start considering other workflows like mixing. One idea was a mode where you could say that the first compressor’s ratio parameter should always be on knob 1 and that would then work with any compressor plugin that has a map available (via tags added to specific parameters in the map). Together with the custom layout feature, users could create their own pages like a dynamics page or an EQ page and the controls would behave the same across all tracks. Let me know if that would already fit your workflow or if you have different use cases in mind!

Not sure if extending the E1 web editor is feasible ATM without a ton of web/JS hacks that might break with the next version of Chrome.
What I could try though is integrating a sentence transformer (quite the pain, most will require python and stuff) that could try to automatically categorize the plugin’s parameters by their names. But that’s kind of a wild idea I had two weeks ago, not sure if it’ll turn out to be a great experience.

Thanks for all your suggestions, which I think are great for venturing into mixing workflows.

2 Likes
25

Thank you so much for your reply!

Your advice was really helpful—now I also keep the settings window active to update Knob Connector more easily.

I managed to “teach” ChatGPT to make Plugin Maps for me in just a few seconds. The idea with the tags you suggested really helped, and the language model handles it perfectly, following the same rules for processing Plugin Maps every time.

Over the last few nights, I’ve customized around 50 plugins. For some plugins I had to look for compromises, since not all parameters fit logically on a single page. There are some plugins that are nearly impossible to map—like the fantastic Michelangelo (Tone Projects), which has two frequency sections, dynamic compression, and a ton of parameters.

I think the most important feature would be the ability to create fully custom layouts. That’s what I’m really hoping for! If it becomes possible to import presets created in the Web Editor, that would be amazing. I really hope future E1 updates will add all these necessary features.

I tried making custom presets for SSL Channel Strip (UAD) in the Web Editor, but was shocked to find that every parameter has its own unique response curve. I managed to get it working with the E1 fader, but it’s nowhere near as precise as what I can do in Knob Connector. I also tried to tackle CSI, and did manage to control track volume using CC Relative, but I couldn’t get any feedback messages sent to the E1. Do you know if anyone has managed to integrate E1 with CSI successfully?

As you can see, I’ve experimented with a ton of things, but I always come back to Knob Connector—it’s simply the best solution out there right now. Thank you so much for your work! I’m really looking forward to future updates. By the way, have you thought about opening up donations? I think it would speed up development—a lot of people bought the E1 specifically for Knob Connector, and I’m sure we’d all be happy to support your work!

1 Like
26

Happy to hear that LLMs can be helpful for generating plugin maps! I want to clarify that the idea with the tags is for a future feature that’ll allow fixed functions per knob (e.g. channel strip for mixing). It’s not yet available so I guess you’re currently using ChatGPT to build consistent maps for your plugins, e.g. the Ratio parameter is always on knob #1?

Not sure why that would be a problem. You can open the plugin and then create a raw map using the action Export map of currently focused plugin. From the looks of the plugin on its website, the optimal layout seems to be:

  • for the 6 big parameters and their corresponding settings parameters, create a module “Main”
    • put the 6 big parameters into a submodule “Bands”
    • put the 6 settings parameters into a submodule “Settings”
    • → the main controls will be mapped to the first knob row and the correspond settings will be mapped to the second map row, aligning perfectly with the plugin’s UI
  • create another module named “Details”
    • create a submodule per distinct section from the plugin’s lower part in the UI and name it like the section (Aggression, Low, Mid, …)

Let me know if there’s still a problem with that plugin.

Unsure what a response curve of a parameter is. Do you mean how the parameters are scaled?
I’m not sure what exactly KnobConnector is doing here that makes it better for this plugin, but I’m happy to hear it works well. :slight_smile:

I’m not using CSI so I have no idea. Whenever I feel like trying it out again, I fail to find the latest version and the latest documentation, let alone understand it and make anything work at all. It’s also not made to handle complex synth plugins well (my main use case) and is not available on Linux. So I didn’t yet find enough motivation to push through.

I feel honoured to hear people bought the E1 because of my plugin! I haven’t yet setup donations, mainly because I find dealing with German tax laws annoying. Maybe I will do so in the future once I better understand the legal and tax implications of accepting donations.

27

Blockquote
Happy to hear that LLMs can be helpful for generating plugin maps! I want to clarify that the idea with the tags is for a future feature that’ll allow fixed functions per knob (e.g. channel strip for mixing). It’s not yet available so I guess you’re currently using ChatGPT to build consistent maps for your plugins, e.g. the Ratio parameter is always on knob #1?

The idea with tags is excellent, and I’m really looking forward to its implementation.

With ChatGPT, I write a prompt where I specify, for example, that Input should always be parameter #1 in a compressor, and Output should always be #6. Moreover, I can ask it to automatically distribute parameters into submodules if there are too many for one page, and it works really well! Sometimes I even create a table to better visualize the concept, and I can set conditions, like “if there’s no Input, put Drive in its place.”

I’ve also managed to use it to create separate submodules for L and R parameters in plugins that have L/R or Mid/Side separation.

Blockquote
Not sure why that would be a problem. You can open the plugin and then create a raw map using the action Export map of currently focused plugin. From the looks of the plugin on its website, the optimal layout seems to be:

Thank you for the detailed instructions for this plugin.

That’s exactly what I would do, but from my experience with Knob Connector, I’ve noticed that when controlling an EQ, it’s not always convenient to switch pages just to adjust the Q (bandwidth). On the main page, I always set up the Freq band and its Gain below (for example, encoders 1 and 7). For convenience, I also create an additional page with Gain and Bandwidth controls. Overall, my point is that a single section isn’t always enough to comfortably manage some plugins.

Blockquote
Unsure what a response curve of a parameter is. Do you mean how the parameters are scaled?
I’m not sure what exactly KnobConnector is doing here that makes it better for this plugin, but I’m happy to hear it works well. :slight_smile:

Yes, I mean exactly the parameter scaling. From what I understand, KnobConnector sends text feedback to the Electra One with the Parameter Value. How did you achieve that? It works perfectly! I tried to figure out how to implement this in CSI and ReaLearn, but I couldn’t get it to work. If it’s easy to explain, I’d really appreciate it.

Actually, I’m very interested in how you managed to implement such accurate feedback—everything works so smoothly! But I imagine there’s a ton of code behind the scenes, which is what makes KnobConnector so great!

I also wanted to share that I managed to implement my own concept and integrate presets created in the Web Editor with REAPER, including MIDI feedback. However, I had to make a big compromise – this only works without textual feedback for parameter values. I spent two nights trying to find a solution, but it didn’t work out. MIDI feedback works, but it’s not as smooth as in Knob Connector.

For hiding textual values, I use a formatter function like this:

function hide(value)
  return " "
end

I achieved this with ReaLearn (Helgoboss), which is a very flexible mapper for different controllers. I also made a script for REAPER that sends SysEx commands to switch banks, presets, and pages on Electra One depending on the focused FX. It works pretty reliably, but I haven’t managed to make it work together with Knob Connector yet. Sometimes E1 hangs or Knob Connector gets confused. Here’s what happens: I have a preset for SSL Channel Strip, and when it’s focused, the script sends a SysEx message with the correct bank, preset, and page. Then, if I open the 1176 compressor, the script sends a message to switch to the Knob Connector preset. But Knob Connector sometimes doesn’t wake up in time and I end up seeing SSL Compressor parameters instead of 1176, or sometimes the submodules of one plugin with the controllers of another.

But I want to make it clear this is not a complaint about a bug – I know you probably never expected someone to go this deep with GPT scripting and try all these wild concepts! :grin: So I’m still working on the script; I tried adding delays, but no luck so far.

For now, I’m testing all these ideas in ReaLearn, and later I’ll make a dedicated thread where I describe everything in detail.

1 Like
28

Noting this for the upcoming tag-system that it’d be useful to assign multiple tags to a single physical knob with a priority.

So when you initially said that:

That was meant in the context of defining one module/submodule with no more than 12 parameters in order to have no need for paging? So it’s not generally impossible to map that plugin, it’s just impossible within the constraint of having no paging? If yes, please let me know why paging is causing friction in your workflow.

The E1 has been built originally to control external synths. As such, it has not a lot of built-in functionality to adapt itself on the fly to changes that rarely happen with external synths but happen a lot when using something like a DAW or a modular Synth plugin. Meaning, I had to create a LUA script for the E1 that adds the missing functionality (like changing parameter name, parameter value texts or parameter ranges, among a lot of other things) and then created KnobConnector to utilize that functionality from Reaper.

This means that the parameter value texts from KnobConnector are depending on the E1 script (the one you downloaded onto your device from here). If you want to have parameter value texts with other control surface plugins, those developers will have to make their own script for the E1.

I’m not sure why the KnobConnector preset wouldn’t wake up - is the E1 not switching to it at all? Sounds like an OS bug, then.
The other problem (inconsistent state in KnobConnector) could happen because I didn’t yet work on supporting suspending and resuming the E1 preset. Thanks for bringing this up! I’ll try to dig into that next week.

What specific role does ReaLearn provide in your setup? E.g., are you doing this basically to have all the other control sets mapped?

29

I said I wanted to have something for you to try out by the end of last week that could fix this but I’m blocked by this limitation.

30

Hello! Thank you so much for your reply!

That was meant in the context of defining one module/submodule with no more than 12 parameters in order to have no need for paging? So it’s not generally impossible to map that plugin, it’s just impossible within the constraint of having no paging? If yes, please let me know why paging is causing friction in your workflow.

I understand that it’s possible to fit any plugin by using several submodules. However, the logic of controlling the plugin becomes a bit more complex. Sometimes, all it takes is a quick glance at the parameter value to make a decision. But when you add paging into the workflow, it slightly complicates the logic of managing VST plugins. Earlier in our conversation, I mentioned that Knob Connector seems to use only about 50–60% of Electra One’s capabilities. All that potential—such as option list controls, buttons, color coding, ADSR control—is not available to Knob Connector users. On top of that, there’s just one control set for parameter management.

I understand your concept and logic. I now also realize that implementing my ideas in Knob Connector would be quite complicated, since sending SysEx feedback requires a control ID, and in a system where users import their own presets, this could cause a lot of chaos in the code.

What specific role does ReaLearn provide in your setup? E.g., are you doing this basically to have all the other control sets mapped?

ReaLearn primarily provides bidirectional control of any Electra One preset. It analyzes the state of the plugin, for example, whether it is focused on the selected track. Parameter mapping is also handled within ReaLearn.

However, lately I’ve been working on a script. In this setup, the script is the final piece needed to realize the whole concept. I’ve learned how to send SysEx with text feedback. I think it’s also possible to send MIDI feedback, removing ReaLearn from the setup entirely. The script also sends SysEx commands for page switching.

I’m going to record a video soon to demonstrate how my concept works. I’ll also share the code in case it’s useful for someone else. I’m still in the process of testing everything. Once I’m sure it’s stable and works well, I’ll publish a detailed script.

After a month of using the Electra One Mk2, I feel like a programmer designing logic and writing code, a mathematician calculating logarithmic and exponential curves, and, honestly, a bit of a madman. It’s a really cool experience — I understood from the start that I was buying a hobby rather than a ready-made solution out of the box. But, nonetheless, I’m getting closer to what might be the most ideal concept for VST control via a controller that doesn’t require an instance on the track.

31

So, I recorded a video showing how my concept works.

At the end, I demonstrate one of the main issues—the dependency on focus. For everything to work properly, you need to make sure that the track is selected and the FX is focused. This is the basic principle behind ReaLearn’s mapping approach. You can remove the FX Focused condition, but then you can end up with situations where two identical plugins on the same track are controlled simultaneously.

Below I’m sharing the code—maybe it will help you or anyone else improve their Electra One experience when integrating with REAPER.

I only guided the logic; all the code and syntax was written by the neural network.

-- Electra One: Output device ID
local midi_output_id = 34

-- Configuration table for presets and parameters
local fx_presets = {
  { match = "SSL E Channel Strip", bank = 0x00, slot = 0x00, page = 0x00,
    params = {
      { name = "Input Select", id = 3, index = 1 },
      { name = "Line Gain", id = 1, index = 2 },
      { name = "Mic Gain", id = 2, index = 3 },
      { name = "Pad", id = 4, index = 0 },
      { name = "COMP Ratio", id = 28, index = 7 },
      { name = "COMP Thresh", id = 29, index = 8 },
      { name = "COMP Release", id = 30, index = 9 },
      { name = "COMP Attack", id = 31, index = 10 },
      { name = "Stereo Link", id = 37, index = 11 },
      { name = "EXP Thresh", id = 34, index = 13 },
      { name = "EXP Range", id = 35, index = 14 },
      { name = "EXP Release", id = 36, index = 15 },
      { name = "EXP Attack", id = 38, index = 16 },
      { name = "DYN In", id = 25, index = 0 },
      { name = "COMP In", id = 27, index = 0 },
      { name = "EXP In", id = 26, index = 0 },
      { name = "HP Freq", id = 40, index = 20 },
      { name = "LP Freq", id = 41, index = 21 },
      { name = "HF Gain", id = 13, index = 24 },
      { name = "HF Freq", id = 17, index = 25 },
      { name = "HF Bell", id = 18, index = 26 },
      { name = "HMF Gain", id = 12, index = 27 },
      { name = "HMF Freq", id = 15, index = 28 },
      { name = "HMF Q", id = 16, index = 29 },
      { name = "LMF Gain", id = 10, index = 30 },
      { name = "LMF Freq", id = 11, index = 31 },
      { name = "LMF Q", id = 14, index = 32 },
      { name = "LF Gain", id = 6, index = 33 },
      { name = "LF Freq", id = 7, index = 34 },
      { name = "LF Bell", id = 8, index = 35 },
      { name = "EQ In", id = 19, index = 0 },
      { name = "EQ Pre Dyn", id = 20, index = 0 },
      { name = "EQ Type", id = 9, index = 39 },
      { name = "Level", id = 22, index = 41 },
      { name = "Output", id = 23, index = 42 },
      { name = "Power", id = 24, index = 43 },
    }
  },
  { match = "API Vision Channel Strip", bank = 0x00, slot = 0x00, page = 0x01,
  params = {
  { name = "Mic Gain", id = 42, index = 2 },
  { name = "Line Gain", id = 43, index = 3 },
  { name = "Pad", id = 46, index = 4 },
  { name = "Cut Filter", id = 89, index = 6 }, -- Assuming Cut Filter as HP (Low Cut)
  { name = "215 LP Filter", id = 90, index = 7 },
  { name = "215 HP Filter", id = 89, index = 8 }, -- Remapped to Low Cut for HP
  { name = "235 Thresh", id = 86, index = 11 },
  { name = "235 Depth", id = 87, index = 12 },
  { name = "235 Attack", id = 83, index = 13 },
  { name = "235 Release", id = 88, index = 14 },
  { name = "235 R/H", id = 88, index = 14 },
  { name = "235 G/E", id = 84, index = 16 },
  { name = "235 On", id = 81, index = 17 },
  { name = "225 Thresh", id = 45, index = 18 },
  { name = "225 Ratio", id = 49, index = 19 },
  { name = "225 Attack", id = 51, index = 20 },
  { name = "225 Release", id = 50, index = 21 },
  { name = "225 Knee", id = 52, index = 22 },
  { name = "225 Type", id = 53, index = 23 },
  { name = "225 On", id = 79, index = 24 },
  { name = "550 HF Freq", id = 63, index = 25 },
  { name = "550 HF Gain", id = 59, index = 26 },
  { name = "550 HF Filter", id = 65, index = 27 },
  { name = "550 HMF Freq", id = 62, index = 28 },
  { name = "550 HMF Gain", id = 58, index = 29 },
  { name = "550 LMF Freq", id = 61, index = 30 },
  { name = "550 LMF Gain", id = 57, index = 31 },
  { name = "550 LF Freq", id = 60, index = 32 },
  { name = "550 LF Gain", id = 56, index = 33 },
  { name = "550 LF Filter", id = 64, index = 34 },
  { name = "560 16kHz", id = 77, index = 35 },
  { name = "560 8kHz", id = 76, index = 36 },
  { name = "560 4kHz", id = 75, index = 37 },
  { name = "560 2kHz", id = 74, index = 38 },
  { name = "560 1kHz", id = 73, index = 39 },
  { name = "560 500Hz", id = 72, index = 40 },
  { name = "560 250Hz", id = 71, index = 41 },
  { name = "560 125Hz", id = 69, index = 42 },
  { name = "560 63Hz", id = 70, index = 43 },
  { name = "560 31Hz", id = 68, index = 44 },
  { name = "EQ Predyn", id = 78, index = 45 },
  { name = "EQ Type", id = 55, index = 47 },
  { name = "EQ On", id = 66, index = 48 },
  { name = "Level", id = 44, index = 49 },
  { name = "Power", id = 85, index = 51 }
  }
  },
  { match = "TrackComp", bank = 0x00, slot = 0x01, page = 0x09 },
}   




-- Default preset
local default_preset = { bank = 0x00, slot = 0x06, page = 0x01 }

-- Cache for storing last parameter values
local last_values = {}

-- States
local last_fx_name = ""
local last_sent_key = ""
local pending_preset = nil
local page_send_time = nil
local last_run_time = 0
local min_interval = 0.02 -- Reduced interval for better responsiveness

-- Send SysEx
local function send_sysex(sysex)
  if midi_output_id >= reaper.GetNumMIDIOutputs() then
    return
  end
  local msg = ""
  for i = 1, #sysex do
    msg = msg .. string.char(sysex[i])
  end
  reaper.SendMIDIMessageToHardware(midi_output_id, msg)
end

-- Trigger ReaLearn feedback update
local function send_realean_feedback()
  local cmd_id = reaper.NamedCommandLookup("_REALEARN_SEND_ALL_FEEDBACK")
  if cmd_id ~= 0 then
    reaper.Main_OnCommand(cmd_id, 0)
  end
end

-- Start sending preset
local function trigger_preset(preset)
  local key = preset.bank .. "-" .. preset.slot .. "-" .. preset.page
  if key == last_sent_key then return end
  last_sent_key = key
  pending_preset = preset
  page_send_time = reaper.time_precise() + 0.2 -- Reduced delay to 200 ms
  send_sysex({0xF0, 0x00, 0x21, 0x45, 0x09, 0x08, preset.bank, preset.slot, 0xF7})
end

-- Send text to E1 controller
local function send_control_text(control_id, text)
  local msb = math.floor(control_id / 128)
  local lsb = control_id % 128
  local numeric_value_id = 0x00
  local text_bytes = {}
  for i = 1, #text do
    text_bytes[i] = string.byte(text, i)
  end
  local sysex = {0xF0, 0x00, 0x21, 0x45, 0x14, 0x0E, lsb, msb, numeric_value_id}
  for _, byte in ipairs(text_bytes) do
    table.insert(sysex, byte)
  end
  table.insert(sysex, 0xF7)
  send_sysex(sysex)
end

-- Main loop
function main()
  local current_time = reaper.time_precise()
  if current_time - last_run_time < min_interval then
    reaper.defer(main)
    return
  end
  last_run_time = current_time

  -- Send page with delay
  if pending_preset and current_time >= page_send_time then
    send_sysex({0xF0, 0x00, 0x21, 0x45, 0x09, 0x0A, pending_preset.page, 0xF7})
    send_realean_feedback() -- Moved here after SysEx send
    pending_preset = nil
  end

  -- Check for no tracks
  if reaper.CountTracks(0) == 0 then
    if last_fx_name ~= "None" then
      last_fx_name = "None"
      trigger_preset(default_preset)
    end
    reaper.defer(main)
    return
  end

  -- Get focused FX
  local retval, tracknum, _, fxnum = reaper.GetFocusedFX()
  if retval == 1 and tracknum >= 0 then
    local track = reaper.CSurf_TrackFromID(tracknum, false)
    if track then
      local fx_index = fxnum >= 0x1000000 and (fxnum - 0x1000000) or fxnum
      if fx_index >= 0 and fx_index < reaper.TrackFX_GetCount(track) then
        local _, fx_name = reaper.TrackFX_GetFXName(track, fx_index, "")
        -- reaper.ShowConsoleMsg("Focused FX: " .. fx_name .. "\n") -- Debug output, remove -- to enable
        if fx_name ~= last_fx_name then
          last_fx_name = fx_name
          local matched = false
          for _, preset in ipairs(fx_presets) do
            if string.find(fx_name, preset.match, 1, true) then
              trigger_preset(preset)
              matched = true
              break
            end
          end
          if not matched then
            trigger_preset(default_preset)
          end
        end

        -- Update parameters for matched plugin
        for _, preset in ipairs(fx_presets) do
          if string.find(fx_name, preset.match, 1, true) and preset.params then
            local param_count = reaper.TrackFX_GetNumParams(track, fx_index)
            for _, param in ipairs(preset.params) do
              local _, formatted_value = reaper.TrackFX_GetFormattedParamValue(track, fx_index, param.index - 1) -- Offset -1
              local control_id = param.id
              if last_values[control_id] ~= formatted_value then
                send_control_text(control_id, formatted_value or "N/A")
                last_values[control_id] = formatted_value
              end
            end
            break
          end
        end
      else
        if last_fx_name ~= "None" then
          last_fx_name = "None"
          trigger_preset(default_preset)
        end
      end
    end
  else
    if last_fx_name ~= "None" then
      last_fx_name = "None"
      trigger_preset(default_preset)
    end
  end

  reaper.defer(main)
end

main()
32

Hey, diving into this again, about to work on some mappings.

Quick question:

Manual says “There is an option to toggle the FX View”. Where is this toggle? Apologies if I’m just missing it but I can’t figure out how to turn this FX View off.

33

Upon a successful device connection, usually after Reaper’s splash screen is over or after you’ve hit OK in the Control Surface settings, KnobConnector registers this and all the other functionality as Reaper action. So you should be able to use “Actions → Show action list…” from the main menu and then simply search for the name of the action, in this case “Show All FX of Current FX Chain”.

1 Like
34

Sorry my friend, totally didn’t catch that this was an Action which says a lot about my observation skills since I’ve been using the Export Map action, ha. That’s weird because I wonder how it got turned on in the first place? Anyway, running that action got me out of that, thank you! Many apologies!

Edit: Cobbled together first map: PSP InifiniStrip. Going to pull together a bunch over the next week, will upload.

PSPaudioware.com - PSP InfiniStrip Stereo.zip (2.6 KB)

1 Like
35

Happy it’s working and thanks for sharing your map!

The InfiniStrip looks like a very flexible plugin, esp. parameter-wise since it can use various modules here and there. Is it’s parameter setup fixed so your map is generic enough to work with any instance/configuration of the InfiniStrip plugin or does your map require to load up a specific configuration/preset within the InfiniStrip plugin?

36

The exposed parameters correspond with one of each the groups: Pre, Gate, Compressor, EQ, Limiter etc, and there are two assignable groups. For instance, I have two Limiters on one of my strips. The Brickwall is controlled by the Limiter group but the InsX generic group is assigned to the other Limiter. The parameter names are generic in this group so have to do some knob twisting to figure out what is what.

It’s a flexible channel strip that I’ve come to use everywhere. Low CPU, low latency, good sound, very flexible.