We’d been talking about mass-spring systems and resonators, so I decided to use a bank of parallel resonant filters to simulate the springs.

I implemented a Resonator class, following Robert Bristow-Johnson’s biquad formula for a resonant LPF [1]. Each resonator tends to ring at a particular frequency, and the impulse response looks like a decaying sinusoid.

By combining a few hundred of those simple resonators, each resonating at a different frequency and driven with a complex sound, you can approximate the sound of a spring reverb.

Here’s the Resonator implementation file – the rest of the plugin source is on the bitbucket page linked below:

[1] http://www.musicdsp.org/files/Audio-EQ-Cookbook.txt

The finished PCB

pucktronix.snake.corral is a computer-controlled dual 8 x 8 analog signal routing matrix. Two independent matrices are presented, each with 8 inputs and 8 outputs. Within each matrix, any input (or summed combination of inputs) can be routed to any output. The device can switch and route any type of analog signal within the range of +/- 5V. The main electronic components of the pucktronix.snake.corral are a Teensy 2.0 and a pair of Zarlink MT8816 analog switching matrix ICs. The MT8816 is a bidirectional 8 x 16 matrix with minimal signal bleed. Like the USB-Octomod, the pucktronix.snake.corral is powered from the USB bus.

A Max/MSP patch which allows the user to define and switch between presets and/or apply various algorithmic rhythmic effects to the switching matrices has also been developed.

Using the pucktronix.snake.corral, a modest number of synthesis modules can be used to create interesting rhythmic and timbral variety. The ability to rapidly switch or reconfigure a large number of signal connections enables a level of rhythmic complexity which is difficult to obtain through other means. Sharp cuts between disparate types of musical material are made possible, and patches can be stored and quickly recalled.

PCBs will be available soon, and you can follow discussion on the project here:

http://www.muffwiggler.com/forum/viewtopic.php?t=51389

More tabulaRasa PCB/Chip kits will be available in the next week. Contact me if interested.

Here’s a demo of some software I developed for Tom Erbe’s music software development course at UCSD. The program allows you to generate modular synth control voltages using a standard AC-coupled audio interface. A diode and capacitor are the only required external hardware. The program is written in C++ using the Qt framework. Download the source, documentation and OS X binary here.

Here’s the pinout:

Each of the pins beginning with “A” is an address pin – they’re how you address a specific X/Y connection. To interface this with an Arduino, you need to connect 11 digital output pins from the Arduino:

• 7 address pins (AX0-AX3, AY0-AX2, these use a strange binary-ish number system – more on that later)
• DATA (High or low to indicate whether to open or close the specified switch)
• CS (Chip Select – you can just tie this high if you’re only using one)
• STROBE (Setting this high writes the DATA to the indicated address)
• RESET (I found that if I didn’t reset the chip upon powering the circuit, I’d get strange results)

Other than that, you need to connect VDD, VSS, and VEE to +, GND, and – supplies.

So, as I mentioned, the addressing scheme is a little strange – and caused me 2 – 3 lost days of head-scratching and frustration. Here’s the info from the datasheet:

As you can see, the address pins indicate an address in a parallel, binary-ish scheme. So, if we’re going to select a particular matrix point – let’s use X3/Y1 – we use all of the address pins at once to indicate the numbers we need. Pins AX0 – AX3 give us 4 X address pins – 4four bits, which lets us count from 0 – 15 in binary. AY0 – AY2 give us 3 bits, 0 – 7 in binary. The 4-bit binary representation of our X address, 3, is 0011, and our Y address, 1, is 001. Consulting the table above, we can look up the value for X3 and see that it is actually 0110, and if we jump down a bit, we see that Y1 is 001. So, to represent our X3/Y1 we just turn our Arduino pins X1, X2, and Y0 high, and leave the others low.

This is all pretty clear, and the addressing follows binary counting rules until you get to X6. Look at the data sheet – X12 and X13 are actually represented by the binary numbers 6 (0110) and 7 (0111). I found an easy fix for my application, but long story short – never assume your chip follows any logic, and always read the datasheet thoroughly. I will admit to much profanity upon discovery of this design “feature” – you can see I had fun on this one…

Here’s my code, apologies for crummy WordPress formatting. Note that I’m only using an 8 x 8 subset of the chip, so my compensation may not work for your needs.

void togglePins(int chip, uint8_t x, uint8_t y, int state){
if(x >= 6){ // compensate for strange x-axis addressing scheme
x += 2;
}
digitalWrite(chip, HIGH);
// next lines convert from integer to binary address
// bitRead returns whether a given bit position in the binary representation of a value is high or low
if(bitRead(x, 0)) digitalWrite(X0, HIGH);
if(bitRead(x, 1)) digitalWrite(X1, HIGH);
if(bitRead(x, 2)) digitalWrite(X2, HIGH);
if(bitRead(x, 3)) digitalWrite(X3, HIGH);
if(bitRead(y, 0)) digitalWrite(Y0, HIGH);
if(bitRead(y, 1)) digitalWrite(Y1, HIGH);
if(bitRead(y, 2)) digitalWrite(Y2, HIGH);
// after address pins are set, set strobe high
digitalWrite(STROBE, HIGH);
// make sure DATA pin is the correct value
digitalWrite(DATA, state);
// reset all pins to low
digitalWrite(STROBE, LOW);
digitalWrite(X0, LOW);
digitalWrite(X1, LOW);
digitalWrite(X2, LOW);
digitalWrite(X3, LOW);
digitalWrite(Y0, LOW);
digitalWrite(Y1, LOW);
digitalWrite(Y2, LOW);
digitalWrite(chip, LOW);
}

It’s a pretty simple function, and you can see the rest of the program in my bitbucket repository.

I’ll be posting more soon about the device I’m building – it’s called pucktronix.snake.corral. I hope this helps decipher the datasheet, and saves some possible head-scratching.

https://bitbucket.org/pucktronix/pucktronix.golgi.apparatus/

Right now, there’s an OS X Standalone App, a Max Collective, and all of the source code.

If anyone is running Max on windows and can compile a standalone for me, that’d be great.

Also, please retweet/facebook/blog this as much as you’d like – I’d love to have as many people as possible see this!