Category Archives: Modular Synthesizer

New Synth Cabinet

I decided to wait on posting about this new project until I had my first module installed and in working order; that day has finally come! :D
What is this? It is a proper Analog Modular Synthesizer Cabinet/Rack. Basically, I built a (48″W)x(11″D)x(24″H) wood cabinet.


Back of cabinet after combining pieces and fitting the acrylic backplanes (covered with blue protective sheet).

The wood is a fairly cheap “whitewood” (most likely Canadian spruce, so far as I could tell from the processing stamps), which I sanded down, stained with “Special Walnut” Minwax stain, then sealed with Minwax Polycrylic Finish. There were some minor misalignment issues (I was trying my best to be as perfect with fitting and sizing as possible), but I managed to tweak the fittings and force some things to fit together better. I am quite pleased with the results, but not so much with my photography (I really need to remember to use my tripod for future documentation).


Back of cabinet with protective sheets removed.

The back of the rack is filled with two full-length, 1/8″-thick acrylic sheets, to which I have mounted the power supply essentials and will eventually use for some fan exhaust (after I have added a few more modules).


Front of cabinet with random pieces of front panel material added for increased realism.

The front of the cabinet is lined with four 1/16″ aluminum L-bracket rails which will eventually have 4 screw-tapped holes per module to hold them in place. The front panels of the modules consist of a 1/16″ 6061-T6 aluminum sheet and a 1/8″ glare-free acrylic sheet with a printed label sandwiched between them. Most people simply use the aluminum sheet with the label on top (sometimes it is at least laminated), but I figured my approach would probably last the longest. My goal is for this cabinet and attached modules to be something I can continue using 20-30 years from now, so I created a front panel labeling approach that avoids the common warping/scratching/peeling/fading problems of most of what I’ve seen of that age. I think I have done so, at minor added expense. :D

Collatzian ChucKathon

Intrigued by a recent XKCD comic regarding the Collatz Sequence, I whipped up a fairly simple ChucK program that runs through the Collatz sequences of increasing odd starting points and assigns the raw number in each sequence as the frequency of an oscillator. I few spatial effects are there as well, to make it a bit more listenable than just a simple oscillator running. I limited the output to (20,1000) Hz because anything else drops straight to one Hz or begins to create undesireably high pitched frequencies that don’t provide much of anything interesting.

I think I’ve heard this familiar-sounding sequence of tones before, but I can’t imagine where. If it has been in something I’ve heard before, I’m sure it was coincidental because there are only so many whole number frequency sequences to be made! :P

ChucK code follows:

21 => int fo;
fo => int f;
fo => int fmax;
0 => int loopcount;
0 => int looplength_timer;
0 => int looplength;

SawOsc osc1 => LPF lp => PRCRev r;
0.1 => r.mix;
f => osc1.freq;
0.4 => osc1.gain;

SinOsc bg => r;
0.025 => bg.gain;
fmax => bg.freq;

SinOsc lpm => blackhole;
0.183 => lpm.freq;
50 => lpm.gain;

r => dac;

//Loop until process is terminated
while(1)
{
//Print values to terminal
<<< “f=”,f, “ttfo=”,fo,”ttfmax=”,fmax,”ttlooplength_timer=”,looplength_timer,”ttlooplength=”,looplength,”ttloopcount=”,loopcount >>>;

183::ms => now;

f => osc1.freq;
if(looplength > 0) { (((looplength $ float) / (looplength_timer $ float)) / (looplength $ float)) * 0.05 => bg.gain; }
else { 0.01 => bg.gain; }
lpm.last() + f + 60 => lp.freq;

if(f%2 != 0) { f*3 + 1 => f; }
else { f / 2 => f; }

if(f < 20) { fo => f; }
if(f > 1000) { fo => f; }

if(f == fo) { looplength_timer => looplength; 0 => looplength_timer; loopcount++; }
if(f > fmax) { f => fmax; fmax => bg.freq; }

if(loopcount == 4) { fo + 2 => fo; fo => f => fmax => bg.freq; 0 => looplength_timer => looplength => loopcount;}

looplength_timer++;

}

ChucK – Differential Equation System Solver

For several weeks, I have been playing around with ChucK: a Strongly-timed, Concurrent, and On-the-fly Audio Programming Language. I have actually been using the software, off and on, for over two years, but only recently started to really use it in the ways I had always wanted to: algorithmically-produced music.

My real dip into the code occured when I jumped on an extra credit assignment for my Differential Equations class, where I was tasked with programming a numerical solver for first-order DEs using the three major introductory algorithms for doing so: Euler’s, Improved Euler’s, and 4th-Order Runge-Kutta (the best of all). It was intended for me to use Mathematica or Matlab, but my program was able to solve the given problems, so it was still acceptable.

The next day, I modified my program for a more general use and to be capable of solving systems of differential equations. I did some research on Lorenz Attractors, and decided that they might be interesting to listen to. Here’s my resulting code and an audio snippet of what it can produce:

ChucK code follows:

3 => int a;
SinOsc osc1[a];
for(0 => int j; j < a; j++)
{
osc1[j] => dac;
(1.0 / a) => osc1[j].gain;
}

float k[a][4];
float x[a];

10.0 => x[0];
20.0 => x[1];
30.0 => x[2];
0.0 => float tt;
0.0001 => float h;

while(1)
{
//Print values to terminal
if( (tt % 0.01) < 0.0001){ <<< “tt=”,tt,”tx0=”,x[0],”tx1=”,x[1],”tx2=”,x[2] >>>; }

for(0 => int j; j < a; j++)
{ ((Std.fabs(x[j]) + 1) * j*20) + 20 => osc1[j].freq; }

h +=> tt;

for(0 => int j; j < a; j++){ h * f(j,tt,x[0],x[1],x[2]) => k[j][0]; }
for(0 => int j; j < a; j++){ h * f(j,tt + (0.5*h),x[0] + (0.5*k[0][0]),x[1] + (0.5*k[1][0]),x[2] + (0.5*k[2][0])) => k[j][1]; }
for(0 => int j; j < a; j++){ h * f(j,tt + (0.5*h),x[0] + (0.5*k[0][1]),x[1] + (0.5*k[1][1]),x[2] + (0.5*k[2][1])) => k[j][2]; }
for(0 => int j; j < a; j++){ h * f(j,tt,x[0] + k[0][2],x[1] + k[1][2],x[2] + k[2][2]) => k[j][3]; }
for(0 => int j; j < a; j++){ x[j] + (1.0 / 6.0) * (k[j][0] + (2.0*k[j][1]) + (2.0*k[j][2]) + k[j][3]) => x[j]; }

.1::ms => now;
}

 

fun float f(int sub, float t, float x, float y, float z)
{
if(sub == 0){ return 10.3*(y-x); }
if(sub == 1){ return x*(28.4-z)-y; }
if(sub == 2){ return x*y-(7.0/3.2)*z; }
}

My work continued quite a bit past that, and I’m debating whether to post the results here, or to keep it quiet until I have enough music to release my first album. That could be this Summer sometime, if ever.

I can only hope.