Slim Series

This is a 9V rack system I'm working on as part of my live setup. The goal was to make highly compact paper circuits with all potentiometers and screws (for patching) mounted to the board, outright eliminating panel wiring, which I find to be the utter worst part of soldering. Not every module on here is 100% done - meaning some of the paper circuits contain errors that I manually corrected during the build process and thus will not be available. Eventually I will fix them and release the revised versions, it's just a matter of time.





Module 1: Rollz

This is a modified version of the 3 rollz and 4 rollz based off of the ciat-lonbarde labrolz/plumbutter schematics. It is basically just a stripped down version of those - it has a single CV input instead of the verso and inverso input of the original, mainly to cut back on size, and I felt I did not really need that functionality.

paper circuit


Module 2: Gongs

This is a remix/remaster of the rollz-5 gongs paper circuit. It contains all the standard mods in addition to a buffered output of the voltage spikes from the flip flop, which is basically what the orange jack is on the plumbutter.

paper circuit


Module 3: 2+2+2

This module contains 2 sawtooth VCOs, 2 wonky VCAs, and 2 resonant low-pass VCFs. Basically just dual synth voices, the VCO is pre-patched into the VCA, and the VCA into the VCF.
The VCO is based off of Synthmonger's very influential (see moritz klein's VCO) 40106 VCO, which can be found here. The "VCA" is based on Will Schorre's "Simple Enveloper", which can be found here. Lastly the VCF is based on the Moduletta VCF, which can be found here.
It is also worth noting these circuits have all been modified to varying degrees, so my schematics will differ a bit from the source material.

paper circuit


Module 4: DDogs

AVDog emulation. It lacks verso/inverso, gonzo/trad, and the orange CV out. However, instead of the orange CV out, there is a "beat" and "offbeat" output which send a short 5v pulse for the peaks and troughs of the DDogs for triggers. Because of the lack of gonzo/traditional switch, the DDogs are locked to being a triangle wave, but if you really felt like it, you could add a waveform switch functionality to the code.

NOTE: THIS CODE IS NOT FINISHED - THE BEAT AND OFFBEAT OUTPUTS ARE ONLY PARTIALLY WORKING, HOWEVER THE CODE IS OTHERWISE FUNCTIONAL

// PINOUTS:
// A0 - aDog frequency
// A1 - aDog filter reso
// A2 - aDog filter freq
// A3 - aDog gate input
// A4 - bDog frequency
// A5 - bDog filter reso
// A6 - bDog filter freq
// A7 - bDog gate input
// D9 - aDog audio out
// D10- bDog audio out
//
// These last 4 outputs are not working
// as intended in this version.
// Will fix soon - otherwise functional.
//
// D2 - aDog beat
// D3 - aDog offBeat
// D4 - bDog beat
// D5 - bDog offBeat
//
// BUILD AT YOUR OWN RISK, USE
// PROPER INPUT PROTECTION
// CIRCUITRY WHEN NECESSARY.
//
// Dylan Barry, 2024, GNU GPLv3
#include <MozziGuts.h>
#include <Oscil.h> // oscillator template
#include <tables/triangle_valve_2048_int8.h> // triangle table
#include <ResonantFilter.h> // subsonic filter

#define CONTROL_RATE 512 // sets CV resolution

Oscil <TRIANGLE_VALVE_2048_NUM_CELLS, AUDIO_RATE> aDog(TRIANGLE_VALVE_2048_DATA);
Oscil <TRIANGLE_VALVE_2048_NUM_CELLS, AUDIO_RATE> bDog(TRIANGLE_VALVE_2048_DATA);
LowPassFilter aFilt;
LowPassFilter bFilt;

int aGain, bGain;

void setup() {
  startMozzi(CONTROL_RATE);
}

void updateControl() {

  digitalWrite(2, LOW);digitalWrite(3, HIGH);
  digitalWrite(4, LOW);digitalWrite(5, HIGH);
  if (aGain > 250){digitalWrite(2, HIGH);digitalWrite(3, LOW);}
  if (bGain > 250){digitalWrite(4, HIGH);digitalWrite(5, LOW);}
  int aButton = mozziAnalogRead(3);
  int bButton = mozziAnalogRead(7);
  // convert digital button input to analog audio
  int aValue = map(aButton, 0, 1023, 0, 255);
  int bValue = map(bButton, 0, 1023, 0, 255);

  // tune dogs with knobs
  aDog.setFreq(mozziAnalogRead(0) << 1); bDog.setFreq(mozziAnalogRead(4) << 1);
  
  // scale filter tuning knobs to be subsonic range only
  int aFreq = map(mozziAnalogRead(1), 0, 255, 1, 10);
  int bFreq = map(mozziAnalogRead(5), 0, 255, 1, 10);  
  
  // control filters
  aFilt.setCutoffFreqAndResonance(aFreq, (mozziAnalogRead(2) + 255));
  bFilt.setCutoffFreqAndResonance(bFreq, (mozziAnalogRead(6) + 255));

  // vca stuff
  int aa = (aFilt.next(aValue));
  int bb = (bFilt.next(bValue));
  aGain = (int) aa;
  bGain = (int) bb;
}

AudioOutput_t updateAudio() {
  // crude gate and limiters, it sounds awful without this
  if (aGain > 255){aGain = 255;}
  if (aGain < 1){aGain = 0;}
  if (bGain > 255){bGain = 255;}
  if (bGain < 1){bGain = 0;}
  
  return StereoOutput::from16Bit(aGain * aDog.next(), bGain * bDog.next());
}
void loop() {
  audioHook(); // required here
}

Module 5: Snare + Utilities

Top circuit is a white-noise snare based off of the korg monotribe snare. Middle is a standard 4017 sequencer with 5 steps, and the last is 2 vanilla rollz circuits.

paper circuit


Module 6: Mixer

This is just a passive 3x6 matrix mixer, I wanted three outputs so that I could process the middle channel separately and then put them together as a stereo mix in the end, since I plan on having the drums and bass primarily center panned.