Custom Unit request: ADDAC 112 Granular Looper

Has anyone tried recreating the ADDAC 112 Granular Looper in the ER301 yet? It looks like an incredibly musical module, with a knob / CV input per function. I think the ER301 could pull it off with the help of a Faderbank via i2c. tbh I’ve had the ER301 since 2017 but I’ve always been intimidated by the recording aspects of it (for no real good reason ahah).

Some examples / info :

IMHO, 90% of the module’s appeal is in the interface. There are some clever functionalities, but approximating it inside the 301 would be pretty tough, I imagine.

One thing that would be nice to see (and have wider utility, too) is the Deviation control.

This implemented random deviation thingie is indeed a very clever functionality! However, and imho, its absolutely wide utility is rather easy to set up with the er301: take an internal or external bipolar random generator and feed it into ANY subchain. The subchain’s gain parameter basically becomes the deviation knob. For hands on control you can remote control a Vca set after the random source (e.g. via i2c from a fader bank). I prefer to use the external and clocked random functions in twin waves for their variety and hands on control because I also use those signals elsewhere in the system. I also tend to add a little sine and an offset axis on the planar…

Granted, having such a solution already baked into a unit is a big plus! (You just can’t reuse that randomness elsewhere in the patch, let alone outside the er301, unless the coding people expose that function at a dedicated output of the unit)

As for clever addac solutions in general and baked in random functions in particular, the deviation knob reminds me of the 506 which in contrast to the 112 uses the two knobs to set a max and a min for the underlying random generator. Working with bipolar random signals, sometimes it’s a genuine pita to dial in some randomness when you’d like to fix a max and or min value for certain parameters in the er301.

There’s probably such a solution for er301 patches and it’s just that I didn’t look for it till now. Any idea which additional unit might help me with min max settings in subchains (other than using unipolar mod sources)?


Nice! It was poorly worded in my initial post, but i suspected someone has a clever solution for the Deviation control, as that’s one part of the 112 that seems fairly straightforward to implement in the 301. And here you are with the solution, thank you.

1 Like

I’d say that you don’t even need a custom unit for this. Seems to me like 90% of the functionality can be easily and quickly build with one audio buffer to record to and multiple granular units reading from that buffer (in case you’re not aware of that functionality, it’s basically applying the concept Neil explained here, but of course with a longer buffer and granular units reading out of it). And personally, I’d much prefer the flexibility that comes from having separate units over the small increase in ease of use you could get out of building a custom unit that does all this in one package - I think once you understand the specifics of how to build this once, you most likely won’t build it exactly like this again, but rather build variations that emphasize different aspects and use different routings. But then, this module also doesn’t appeal all that much to me, so that might just be my personal preference.

The only huge benefit of this module that is apparent to me from the demos is the UI with dedicated knobs and inputs for each function, which you can of course not replicate on the ER-301. But the sort of sounds I’m hearing there are basically what my first experiments with the ER-301 granular units sounded like (a bit more polished, of course, but that has nothing to do with the module and everything to do with me :smiley: ).

I’d be happy to help walk you through problems you encounter while realizing similar functionality on the ER-301. But I wouldn’t go through the effort of building a custom unit, as it feels like just putting together one specific configuration of functionality that has already existed on the ER-301 for years, just for the sake of copying another module, which seems not so great to me.


I think you can though, with the internal / feedback patching via ‘Local’ all the units’ outputs are exposed when assigning the input for any chain — so it’s possible to grab the output of the VCA you mentioned and use it elsewhere.

1 Like

of course, so true! just another way of the er301 to incorporate the devious deviation effect :partying_face: but that is still restricted to the chain you’re working in, right? which is why i tend to put all mod sources into global chains (or the hardware inputs of external sources for that matter) so i can use them in every output chain…

also, my poor wording meant to discuss some randomness “hidden” inside a custom coded unit with which it is up to the creator of the unit whether the output of the random generator is exposed e.g. for that very local internal patching (per chain) that you are describing. however, i’d probably prefer a dedicated random solution outside the addac 112 simulator unit, preferably in a global chain… :rofl:

what an awesome offer! and i hope @sisyphus69 will take it. because though i also haven’t the slightest interest in having an exact copy of the 112 inside my sound computer i’d love to learn more about the granular and (manual/automated?) looping approaches in it and how it could be first translated and second also transcended with the er301.

i think translating functionalities known from other modules/instruments is quite a good way to learn the quirks and infamous capabilities of the er301. it’s also good against the intimidating effects this complex instrument can have on us. i gained quite some insight into the clocked sample player (with which i herby offer to help with) but i still get intimidated by any granular or live looping solution! and i’ll need them soon :rofl:

@x2mirko, so you’re saying that @NeilParfitt 's youtube video from 2017 is still a good starting point
(i guess for the shared buffer thing?)? man, that video aged well then…

1 Like

i believe so, but only in the meaning that you are restricted to the same top-level chain (the one that has a physical output in the end). I believe we are free to use outputs of any units from any sub-chains of that top level chain anywhere within that chain.

The other option would be to set up the randomness shenanigans in Global Chains and then use it anywhere :slight_smile:

1 Like

I think most of his videos aged pretty well. The concepts mostly still apply, even though the GUI looks quite different in many places. But yeah, I mainly meant the shared buffer thing - his application in that video is also cool, but if you apply the same concept to a longer buffer, you basically already have a long-running looper that you can push audio into whenever you want.

I honestly thought this was rather basic stuff, but if there’s interest, I’m probably wrong. So let’s do it. The basic setup I had in mind to build a similar thing would be this:

Start by putting a “Dub Looper” unit into a channel (our recording channel). Set the channel input to one of the audio inputs and assign a new buffer to the Dub Looper (whatever length you want, but let’s say 10 seconds). You can now already record something into that buffer and have it played back (in case you don’t know how: first activate “engage”, then “punch” in to start recording and “punch” out again to stop recording). But we can’t pitch shift anything, and there’s certainly no control over grains, so what we’ll actually do is ignore the dub looper completely for sound generation and only use it for recording into the buffer.

Next we want the basic loop playback functionality with pitch shifting. I’d use the “Grain Stretch” unit for this. We’ll add it to the same channel behind the Dub Looper (or a different channel if you prefer it to have it’s own separate output, it does not matter). Set it to use the same audio buffer by going into the setup of the Grain Stretch and choosing “Select from Pool”, then pressing Enter to select the buffer. If you have already recorded something into the buffer, on the second step, you should already hear it being played back now. You can change both the speed of playback (via speed) and the pitch (via the 1v/oct control).

Now we want to add the granular engine for creating grains on top of the whole thing. Again, we can either separate it out to a different channel or (if we use our channels for other things or want it mixed anyways), we can also just add a “Mix” unit to the channel we’ve been working on and put our grain generation into that mixer channel.
We’ll use the “Manual Grains” unit. We’ll add it wherever we want (see above) and then set it up to use the same audio buffer that the Dub Looper and the Grain Stretch units are already using (same setup, “Select from Pool” + Enter). This unit basically plays back one grain at a time whenever it is triggered. In order to get it to do something interesting, we need to a) trigger it and b) manipulate it’s parameters

We’ll start with the trigger. What we do here depends on what we want to do with the whole device. Maybe you want to use something external to trigger grains (a sequencer? An oscillator? Something like Maths EOC?). Or you want to build it all inside the ER-301. Since the external part is easiest (just open the “trig” chain of the “Manual Grains” unit and set the input of that chain to be an external input (e.g. A1) and patch your trigger there), let’s consider two options for building it inside: using an oscillator with varying frequency to create “clouds” of tiny grains and using a clock to produce longer grains on divisions of a beat.

First off, an oscillator. Navigate into the chain of the “trig” input on the “Manual Grains” unit and add a “Aliasing Saw” unit there (you’d want a square wave oscillator, but the saw triggers it just fine and is part of the core libs). You should immediately start hearing grains being triggered (it might be hard to tell if this is actually the case depending on what is in your audio buffer). It’ll be a constant stream of identical grains at 27.5Hz. Not very exciting. To make it a tiny bit more interesting, you can add some sort of random modulation to the v/oct input of the “Aliasing Saw” unit. Again, I’d do this with Teletype, but I recommend checking out the “Pingable Scaled Random” unit from Accents to do it within the ER-301.

Alternatively, we can use a clock and trigger grains at divisions of that clock (or randomly, but only on divisions). To do that, we again get into the “trig” chain, delete the “Aliasing Saw” and instead add a “Clock (BPM)” unit. It has multiplier and divider controls so you can set it up to trigger at whatever rate you want (or sync it to an external clock using the “sync” input). If we don’t want it to trigger constantly, we could process the clock signal further, e.g. by adding a Lojik “Chance” unit behind it. Now we can set the chance that on a given clock pulse a grain will be triggered. Or you could put a sequencer here or whatever else you want. Everything in this chain is a great target for modulation.

But no matter how we trigger the grains, they still all sound the same and that’s quite boring. So we want to add modulation to the parameters of the “Manual Grains” unit. Of course, you can do whatever you want here. But for the sake of the explanation, let’s go with something incredibly simple: Just randomize everything :smiley:

Again, we’ll use the “Pingable Scaled Random” unit from Accents here. Just open a parameter chain on the “Manual Grains” unit (e.g. “start” to influence the position of playback of the grain), drop a “Pingable Scaled Random” unit in there, navigate into the “trig” chain of that unit and set the chain input. Since we want each grain to have different parameters, we’ll just use the trigger we’re generating to start grains. In order to do that, open the menu to set a chain input and then select “Locals” on the smaller screen on the bottom. Now you should see the units in the chain we’ve created so far. Move the encoder to select the “trig” input of the “Manual Grains” unit and press enter to confirm. Now the “Pingable Scaled Random” unit will create a new value for each grain. All that is left to do is to navigate up and set the gain parameter of the chain such that the random values actually influence the parameter we want to modulate. Rinse and Repeat for all parameters (you can also copy the “Pingable Scaled Random” unit you created inside the first channel and simply paste it into the other channels - that way you don’t have to redo the routing.

This (with some tweaking of the parameters to taste) should already get you quite close. It should at the very least give you a starting point and a lot of ideas on what to do with this.

Additional things that could be done to improve upon this:

  • Recording probability, delay, etc. This can all be accomplished by putting some devices into the chain controlling the “Punch” of the Dub Looper. For example, you can put in a square wave (or a clock) and add some logic behind that. Personally, I’d simply control this sort of thing with Teletype, so I never put in a lot of effort into figuring out how to do this within the ER-301. But it should be rather easy using all the cool units in Accents and Lojik (particularly Chance and Latch/TLatch seem like they would make a solution easy)
  • Add quantization to scales. There’s a great quantizer in the core lib that you can just add to the 1v/oct chains of both the Grain Stretch and the Manual Grains unit.
  • Add slices to the buffer (you can use slices on any buffer, not just prerecorded samples) and use those to skip around with the looper if you like.

I honestly think that it is basic stuff, at least in terms of being probably one of the most sought after features of the er301 :smiley:. In terms of fully understanding this shared buffer method as well as setting it up, I’d argue that it is beyond basic knowledge, at least for beginners on the er301 and of course for people like @sisyphus69 and me who are on board since 2017 but somehow failed to embrace the granular and live looping trends. :joy:

But here we are (again). In my case a good friend recently got addicted to eurocrack. He used granular on iPad and live looping on hardware as well as on pc and tries to move those to modular. He’s actually eyeing that addac112 and I’m wondering for quite a while now, whether I should recommend him to go down the many rabbit holes of the er301 instead… so I’m finally failing to resist granular and live looping so I can give him the best informed advice. Well, live looping already was on my bucket list, because I planned to use it in a band context. But the pandemic put the band on rest and other construction sites also kept me at a safe distance…

Now, @x2mirko delivered quite an impressive walk through with plenty of explanations and examples! And I’m so glad that this community doesn’t respond to people being late to some games with an impatient “elsewhere-in-the-forum” response!

After my first read I’m pretty sure that I’ll get some gratification when I finally follow these instructions. And while I’m at it I’ll check whether a beginner would understand these lines, I.e. what else would we have to add so that my friend can fully grasp what needs to be done.


Wowe . Reading the replies in this thread has been incredibly humbling. I need to spend more time with the ER301 and explore the uncharted areas to get familiar with some of these functions you mention. Thanks for the insight everyone

Thanks for breaking it all down! very helpful.

How would you go about changing the presets / sample / loop file mid performance?

I actually don’t know about that one since I usually don’t work with presaved files but rather with recording buffers that I sample into live.

I do know that if you load a sample to begin with (i.e. you select a sample from the card in the very first step and then select the resulting buffer from the pool in other units), you can replace that sample with another sample later when you’re in admin → sample pool (via the “replace” option) and the sample will be replaced for all units that are currently using the old one. However, I don’t think you can somehow load a sample into a buffer that has been created as I described it further above. So this method would only be applicable if you ONLY want to work with prerecorded material and don’t care for the live sampling at all.

Or at least, I don’t know how to accomplish that if it is possible. You could of course load a sample into a sample play and then play that sample players output into the input of your recording looper, thus filling the buffer with it, but that’s hardly the same thing as just loading a different loop immediately when you need to.

Maybe someone else with a different workflow knows how to do this :slight_smile: