Getting Started with the Reverbalizer

The Reverbalizer is a relatively simple hackable effects pedal based on the FV-1 multieffects chip by Spin Semiconductor. More information is available on the product page; this is a quick guide to getting up and running with the Reverbalizer.

The photo at the top of this post pulls out the main parts of the board. They are:

1. Analog audio in. This is a 1/8″ mini jack and should be a line level input. If the input is too hot the red clip warning LED will light.

2. Analog audio out. An 1/8″ mini jack with line level audio out; try it with powered speakers or an amp.

3. Programmable external EEPROM. Your board comes with a little EEPROM board with a header and socket; this has a 4kB EEPROM memory chip that can be programmed with 8 additional effects. We have an Arduino sketch that let’s you flash this EEPROM over I2C (see below).

4. EEPROM select switch. The FV-1 has 8 built-in “internal” effects; this switch toggles which bank of effects is active, the internal 8 or the “external” 8 on the little EEPROM board.

5. A/B/C effect potentiometers. The functions of these potentiometers change depending on the effect that is selected. See the table below. When making your own Spin effects you can program these inputs.

6. 3 effect select switches. This was our alternative to using an expensive rotary encoder to select the effects. These 3 switches choose the effect using a 3 bit binary code (see below).

7. Power jack. This takes a DC voltage in the range 5V-9V. The jack is center positive, so don’t power the Reverbalizer with your center negative stomp box power supply.

As an bonus easter egg, all Reverbalizer boards are signed by theremin virtuoso Edie Vetter on the back.

The Effect Select Switches

You select effects by changing the state of the three select switches. The 8 positions map to a 3 bit code (which is the “program number” in the table below) as in this illustration:

These select the following effects from the built-in internal bank:

The external EEPROM comes pre-programmed with 8 effects created by various folks around the Spin forums. I’ll update this with credits and more info once I track down my notes on how we programmed these sample sounds!

Programming the EEPROM

You can flash the EEPROM with your own effects. The EEPROM connects to an Arduino microcontroller using the I2C protocol. The pins on the header are:

To flash the EEPROM, attach the board to the analog header of an Arduino Uno as in the following photo (I2C may be on different pins for different variants but you can always hook it up on a breadboard).

You can download the code for the EEPROM burner via Github. We used the Spin Semiconductor compiler to create the ROM.h files that are included in the download, which is the subject of another tutorial.

/*   
  *   Reverbalizer External EEPROM Burner
  *
  *   Note that you also need the files ROM1.h through ROM8.h
  *   These can be downloaded via Github here: 
  *   https://github.com/fluxly/ReverbalizerEEPROMBurner
  */

#include  //I2C library
#include 
#include "ROM1.h"
#include "ROM2.h"
#include "ROM3.h"
#include "ROM4.h"
#include "ROM5.h"
#include "ROM6.h"
#include "ROM7.h"
#include "ROM8.h"

#define EEPROM_ADDR 0x50
#define MAX_LENGTH 512

byte* prog_addr[] = {(byte *)ROM_00, (byte *)ROM_01, (byte *)ROM_02, (byte *)ROM_03, (byte *)ROM_04,  (byte *)ROM_05, (byte *)ROM_06, (byte *)ROM_07 };

// data can be maximum of about 30 bytes, because the Wire library has a buffer of 32 bytes
void i2c_eeprom_write_page( int deviceaddress, unsigned int eeaddresspage, byte* data, unsigned int page ) {
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddresspage >> 8)); // MSB
    Wire.write((int)(eeaddresspage & 0xFF)); // LSB

    for ( int c = page; c < page+16; c++) {
      //Serial.print("-->");
      //Serial.println(pgm_read_byte_near(data+c));
      Wire.write(pgm_read_byte_near(data+c));
    }
    Wire.endTransmission();
}

byte i2c_eeprom_read_byte( int deviceaddress, unsigned int eeaddress ) {
    byte rdata = 0xFF;
    Wire.beginTransmission(deviceaddress);
    Wire.write((int)(eeaddress >> 8)); // MSB
    Wire.write((int)(eeaddress & 0xFF)); // LSB
    Wire.endTransmission();
    Wire.requestFrom(deviceaddress,1);
    if (Wire.available()) rdata = Wire.read();
    return rdata;
}

void setup() {
  delay(1000);

  pinMode(16, OUTPUT);
  pinMode(17, OUTPUT);
  digitalWrite(16, HIGH);
  digitalWrite(17, LOW);
  Serial.begin(9600);
  while (!Serial) {
  ; // wait for serial port to connect. Needed for Leonardo only
  }
  
  Serial.println("Initialize EEPROM communication");
  Wire.begin(); // initialise the connection
 
  // Write the data in the setup(), read in the loop() to confirm it flashed

  for (int program = 0; program<8; program++) {
    Serial.print("Writing program ");
    Serial.println(program);
    for (int page=0; page
Each ROM file is formatted as a C header file that encodes exactly 512 bytes and puts it into program memory. On the Arduino Uno that is the same 32k of flash memory that your program resides in; all 8 ROMs would not fit the 2K of RAM the Atmega328 offers. These bytes get flashed directly to the individual addresses of the EEPROM; 512 bytes * 8 = 4k of memory. The ROM files look like this:
const unsigned char ROM_00[] PROGMEM = {
0x40,0x00,0x02,0x84,
0x00,0x00,0x00,0x09,
0x80,0x00,0x00,0x0D,
0x80,0x00,0x00,0x0D,
0x00,0x10,0x04,0x25,
0x00,0x00,0x04,0x26,
... // many lines deleted for brevity
0x00,0x00,0x00,0x11,
0x00,0x00,0x00,0x11,
0x00,0x00,0x00,0x11,
};