Relay Bypass: conception and relay bypass code

You might already have heard about "relay bypass", or even used it without knowing it. It a different true-bypass system than the classical 3PDT switch. Instead of using a mechanical 3PDT switch, a soft switch, a microcontroller and a relay are combined to turn the effect on and off.

 So... Why bother? My 3PDT switch is great, don't you think?

As you may already know, 3PDT switches are the main cause of guitar pedal failure. These switches are not particulary though, and they often break, especially as we smash it continuously with our feet on stage.

A classical high quality 3PDT switch is rated for 30,000 activation cycles. With relay bypass, we use a relay that will play the mechanical role of connecting ins and outs. Relays are usually rated between 10 and 100 millions cycles! Thus, this system is much more reliable.

Moreover, the soft switch that we use to activate the guitar pedals also last longer than a 3PDT, usually around 50,000 cycles! They are also easier to replace, as there are only 2 connections to make with the relay bypass system, and not the full 3PDT wiring.

This blog post will present you how does it work, and how to make your own relay bypass system using a microcontroller, from the beginning to the end! Long stuff (but good stuff?)!

Summary

• How does relay bypass work?
• Relay bypass circuit schematic
• The microcontroller
• The relay
• PIC/PC communication device: the PICKIT2
• PIC configuration bits
• C source code to sense the switch

---

How does relay bypass work?

A relay works like a switch that is activated by a given voltage. There is a coil inside; when it receives a precise current, it will activate the internal switch of the relay. Therefore, the symbol looks like a switch:

The coil is symbolized with a rectangle, and the internal switch by a classical switch symbol. When the correct voltage is provided to the relay, the switch is activated and change its status.

The internal switch can be of different nature, and some relays have an internal DPDT built in! This will allow us to switch between "bypass" and "effect on" status.

Unfortunately, relays with an internal 3PDT are quite rare and really big... So how are we going to do to light up the LED? We are going to use a microcontroller. A microcontroller is a 8 pins digital IC that is kind of a mini computer! We can burn the microcontroller with a code that will tell it precisely what it should do. Here, we are going to say to the microcontroller : "activate the relay when I press the switch, and light up the LED"


Here is what it looks like in a commercial pedal (Dr Scientist) :

The switch is connected to the microcontroller that will "sense" when it is pressed: it will then activate the relay and the LED: the effect is on!

It look simple, but trust me, it is not as easy as it seems to implement ;)

---

Relay bypass circuit schematic

Here is the schematic of the relay bypass circuit:

The microcontroller is a PIC, the PIC12F675. PICs are a very common type of microcontroller, produced by the company MicroChip. There are many different PICs, with a different number of pins (from 8 to 64 or more!), several options (analog / digital converters...etc). The PIC12F675 is an 8 bit PIC, quite cheap, small and with a lot of options. It will be perfect for the relay bypass circuit!

Of course, you can use a different type of microcontroller, like the ATtiny85 that can work with Arduino. I choosed the PIC12F675 because there are many infos about it on the web, and you can go a bit further than Arduino systems with it. Also, it uses the C programming language, which is a simple yet very functionnal programming environement.

As you can see on the schematic, the PIC12F675 requires a 5V regulated voltage on its pin number 1, and pin number 8 should be connected to the ground. To supply the 5V regulated voltage, we can use a voltage regulator, the 78L05, which is commonly used on circuit implementing a numeric chip, like the Rub a Dub Reverb. The C1 capacitor will avoid any variation of voltage due to the power supply.

Then, the relay is wired as a true bypass DPDT: signal enter through one pin, and is redirected either to the output (bypass), either to the input of the circuit board (SND).) The diode connected to the relay avoid the coil of the relay to blow up the circuit when it is turned off (it can generate a parasitic current).

---

The microcontroller

Each remaining pin of the microcontroller (pins number 2, 3, 4, 5, 6 and 7) can be used either as an input or an output. They are called GPIOs (General Purpose Inputs / Outputs) and you can configure them as you want with the code we are going to burn in the microcontroller:

• Input: the microcontroller can "sense" what happens on this pin: value of the voltage, pressed switch...etc. It can receive "electrical data" on this pin.
• Output: the microcontroller can send an electrical signal from this pin to the components connected to it. If you send a specific voltage or a voltage with a precise frequency, you can send "electrical data" to other numeric chips like digital potentiometers.

If we think a bit about it: the GPIO connected to the LED will be an output (it will provide current to the LED), same thing as well for the GPIOs connected to the relays. The GPIO connected to the switch will have to "sense" when the switch is pressed, therefore it will be an input. Thus, we have 1 input (pin number 6) and 3 outputs (pins number 2, 3 and 7).

BEWARE : in order to make it easier and logic (irony inside...), the numbers of the GPIOs are different from the number of the pins... Here is a schematic:

Thus, pin number 2 is GPIO number 5, pin 6 is GPIO 1...Etc. In the code that we are going to write, the GPIOs that we will use will have to be named with the GPIO numbers, not the pins numbers!

Good!

Each GPIO can also be configured to be analog or digital:

• Analog : an Analog to Digital Converter (ADC) included in the chip can be use to "read" precisely the value of a voltage, on a 0 to 255 scale (the PIC12F675 is an 8 bit chip, but 16 or 32 bits chips also exist, allowing you to have bigger scales, like 0 to 1023). We can also use a Digital to Analog Converter (DAC) to send a precise voltage on an output.
• Digital : the chip will detect "on" or "off" states, that is to say a "high" or "low" voltage. It is like reading 1 or 0 for a computer. Here, the "high" value will be 5V (it depends on the chip), and "low" value 0V.

In our cas, we will use 5V to the relay and LED when the effect is on, and 0V when it is off: output will be digital.
To sense the switch, no need to use a "scale" for sensing it: it is either on or off! So the input will be digital as well.
Setting the states of the GPIO high or low will be enough to fully control the relay and LED.

We will see later how to do that in the code example.

---

The relay

There are many many different relays out there, that will need different voltages to switch. They have different sizes and shapes. Reed relay look like integrated circuits, classical relays like big boxes, with different numbers of pins... Also, there is specific power needed to switch the relay : the activation power. Here are a few examples of relays:

So; we are going to use the high state of the GPIOs to activate the relay. The "high state" is 5V here, so we need a relay that can be activated by a 5V voltage.

For our usage, we need a relay that is:

• Small: if we want the circuit to fit in a 1590A enclosure, we need to make as small as possible. The smaller the better!
• Activation with a 5V voltage: 5V is the "high" value that the microcontroller can send from a pin, so we need a relay that can be activated with such a voltage.
• Low activation power: the microcontroller does not deliver a high intensity output. Generally speaking, it is around 20 mA maximum, which makes a 100mW power on an output. Remember that we can use a transistor to amplify a bit the current if needed.
• DPDT: we need a DPDT to switch the input and the output at the same time.
• Affordable: we do not want this system to cost 100 times the price of a 3PDT... As it can last 3 times longer than a 3PDT bypass system, we can aim a total cost of around 3 times the price of a good 3PDT, that is to say 10 euros approximately. The soft switch already cost around 3 euros, which let 7 euros for all the remaining parts, PCB included!
• No surface mount devices: we want something easy to assemble and repair.

So I had to read a lot (like, a lot!) of datasheets of different relays to find the perfect fit...

And the winner is...

The Takamisawa NA05W-K ! Small sized, cheap (less than 2 euros!), 140mW activation power, DPDT... Seems like a perfect candidate for what we want to do!

The Panasonic TQ2-L - 5V seemed also like a good option: 140mW, a bit bigger though, and more expensive (around 4 euros). However, it is a latching relay which is a bit different from the takamisawa that is a non-latching type.

---

Relay bypass code (in C)

So, we know what we are going to do, which components we need... We "only" have the PIC to code left to do!  

PIC / PC interface

In order to code and burn the chips, we need something to connect it to our computer, that will allow us to burn the code in the microcontroller.

For PICs, it is very simple: MicroChip manufactures and sells an interface called PicKit 2 (there is a version 3, but it is more expensive and not very different from the version 2). I strongly advise you to buy an adapter that will make the overall process way simpler than using a breadboard.

There are plenty of good deals online for the PicKit, you can find it for 20 dollars easily. It is like buying a soldering iron: you can use it many times so it is worth the investment! Also, do not forget to buy a bunch of PICs (12F675).

As all the PicKit components (including source code) is in open data (good call from MicroChip!), there are some clones available out there. They are usually less expensive, but buying "the real thing" can save you from a lot of compatibility troubles... So I strongly advise you to buy the original PicKit2.

On your PC, you need three softwares to work correctly with PICs:

1. MPLabX: it is a free software (well in its simplified version that is perfect for us) that you can download on the MicroChip website. It allow us to code the PIC in C (instead of assembly language that is a low level, very complex language). Click on the "download" tab on this webpage.
2. XC8 compiler: the compiler will transform the code that we write in C into a understandable code for the PIC: the hexadecimal format. You can download it on the MicroChip website ("download" tab as well)
3. PicKit2 software: it allow your computer to "speak" with the PicKit2 interface. We will use this software in the final steps of this tutorial to burn the code. Download it here. (PicKit2 install A)

Setup everything.

Once you are done with the setup of the softwares, place the PIC correctly on the adapter:

Connect it to the PIC correctly: the VPP / MCLR pin should be connected to the pin of the PicKit2 with an arrow. Connect the PicKit2 to your computer with the USB cable.

Now, open PicKit2 on your computer. It should be able to detect the PicKit ("PicKit 2 connected"):

If it does not recognize your PicKit, disconnect and reconnect the PicKit. It should work. All the "3FFF" at the bottom of the "program memory" window reprensent the memory of the PIC. We will see the one burnt in our chip once we have detected it.

Lets detect the PIC. In order to do that, you need to select the type of Pic you are using. Click on "Device Family", then "Midrange", and "Standard":

If you click on "Read", it should detect the PIC. Sometimes, it is quite difficult to get it working. Verify that the PIC is correctly placed on the adapter. Sometimes the ribbon cable can be the problem: just connect the adapter directly to the PicKit2. You can also disconnect / reconnect the Pic or adapter. Once it detects it, you should have something like this:

Good! We can program now!

PIC configuration bits

Before doing anything else, we need to configure the PIC, in order to set the features that we need or not. This step is absolutely necessary, the PIC will not even initiate if you do not do it.

If you are lost at any step of this tutorial, you can also watch this video that explain quite nicely how to configure the PIC.

To configure the PIC, we first need to create a project in MPLAB. To do that, open MPLab X, click on "File", "New Project", then choose "Standalone Project" and click "Next". You need to choose the type of PIC that we are going to use. Just type the  name of the PIC in the "Device" bar, PIC12F675:

When ask to select a header, click on "none". Then you have to choose the "tool" that is the interface between the Pic and your computer. Here, it will be the PicKit 2:

Then, you are asked to choose the compiler, select XC8 and click on "Next". Then, name your project ("Relay Bypass for instance), and click on "Finish". It will create a folder in the "Projects" windows tab on the left, containing several other folders:

Ok, now everything is set, and we can configure the PIC properly.

Lets configure the PIC. To do that, we need to create a header file that will contain all the configuration information (="configuration bits"). Click on "New", "File". A window will open. Select the "C" folder (we want to program in C, but you can program in other languages depending on the folder you choose: C++, assembler (good luck with that), XML...), and select the "C Header File":

 Click on "Next", and choose the name of the header file ("header" is good enough), then click on "Finish". The "header.h" file should appear in the "header" folder:

Double click on this file and it should open in the main window. On the bottom right corner, click on the "configuration bits" tab:

In this menu, we have all the possible options to configurate the PIC: oscillater, code protection...etc. Here are the different options and how we are going to configure them:

• Oscillator Selection bits : the oscillator is the clock needed for the PIC. It can be either external (using a quartz, and 2 GPIOs), or internal if the PIC has an internal clock. The PIC12F675 has an internal clock, so we are going to use it, by using the "INTRCIO" option. The clock is needed here to use functions like __wait_ms() that will allow us to pause the program for a specific amount of time (in milliseconds).
• Watchdog timer : not necessary here: "OFF"
• Power Up Timer enable bit : add a 72ms delay when the PIC is turned on. Not needed here: select "OFF"
• GP3 / MCLR pin function select : the pin 4 of the PIC can be used as a "reset button" (=MLCR), or as a classic GPIO. Here, we do not need a "reset" button, so select "OFF" to use it as a classic GPIO. 
• Brown-out Detect Enable bit : the "Brown Out" circuit is a simple comparator circuit that checks that the voltage supplied to the PIC is not too low. It avoids memory corruption issues if the PIC is undersupplied. However, the PIC will draw more current. As we do not use the internal memory here, select the "OFF" option.
• Code protection bit : do you want your code to be visible by others or no? If you want to protect your code (for a commercial pedal for instance), you can select "ON". Here, however, as the code is public on my blog, no need to protect it so you can select "OFF" :)
• Data code protection bit : PICs have a small internal memory called EEPROM. If you want, you can prevent people from reading what is in it by activating this option. Here, we do not even use the EEPROM so you can select "OFF".

Once you are done with that ("INTRCIO", then everything "OFF"), you can click on the  big "Generate Source Code to Output" button. It should display a code in the "Config Bits Source" window. Select and copy this code:

You should have this in the main window:

Select everything from #ifndef, and delete everything (yep!). Then paste the code we just copy. You should have this now:

We are nearly done! One last thing: we have to define the internal clock frequency. Here, we will use a 4 MHz freuency. Just add this code under the configurations bits you copied before:

// Define oscillator frequency
#define _XTAL_FREQ 4000000

The "//" symbol allows you to write some comments in your code, useful in order to remember why you wrote that. I strongly advise you to put as much comment as you need in your code, in order to be perfectly sure that you can understand everything when reading it. It will be easier to reuse it later for other things this way!
There it is! We are done with configuring the PIC. Save everything, and we can code now.

Relay bypass code: sensing the switch and activating the relay

First, let's create the file containing the main C source code. To do that, click on "File", then "New File". Click on the file C (to use C language), then choose the "C Main File" type of file:

Then, choose the name of the file, and click on "Finish". The file should be placed in the "Source Files" folders:

You should have something like this in the main window:

Delete everything below the two #include, and add these code lines : the two first ones add two libraries that we need to make the code working: "stdint.h" will allow us to use variables, and "xc.h" will make our code compatible with the xc8 compiler. Finally, we have to include the configuration bits with the "header.h" file:

// Supplementary libraries
#include <stdint.h>
#include <xc.h>
// Include configuration bits
#include "header.h"

You should have something like this now:

We can start now to code (finally!):

• when the switch is pressed, we have to know the state of the pedal, and change it: if the pedal is off, we have to turn it on and vice versa.
• when the pedal is on, we have to activate the relay and to light up the LED.

We are going to code all of this in a loop that is called the main() loop. The PIC will do again and again every instructions embedded in that loop starting from the top to the bottom. Write it like this:

void main(void) {
}

First, we have to create a variable that will define the current state of the pedal. Here, I named it "state". It can have two values : 1 (pedal is "on") or 0 (pedal is "off'").
When the PIC start (when a power supply is connected to the pedal), we can make the effect off by defining the initial value of state equal to 0. Write this code inside the "{}":

uint8_t state; // variable that will define the pedal's state: on or off
state=0; // pedal is off when starting

The first line of code create the "state" variable that is an unsigned integer = positive integer ("u" = unsigned, "int" = integer). Do not forget the semicolon at the end of every instruction!

As you on the above examples, you can add comments in your code with the "//" symbol. Do it often in order to be sure that you understand clearly every part of your code!

We have now to write some instructions to correctly initialize the PIC, and to tell it what things it should use or not. Here, as we use only digital GPIOs, we do not need the DAC and ADC converters. We are going to inactivate the comparator as well (it is a circuit that can compare the voltages between two pins of the IC). To do that, we write this:

ANSEL = 0; // no analog GPIO

CMCON = 0x07; // comparator off 

ADCON0 = 0; // ADC and DAC converters off

Lets define the nature of each GPIOs: we are going to tell the PIC which ones are inputs and which ones are outputs. Here, we need the GPIOs 0, 4 and 5 to be outputs, and the GPIO 1 to be an input:

TRISIO0 = 0; // pin 7 is an output (0 like "Output")
TRISIO4 = 0;
TRISIO5 = 0;
TRISIO1 = 1; // pin 6 is an input (1 as "Input")
GPIO=0; // all the GPIOs are in low state (0V) when starting

Ok! The PIC is ready to start now! We are going to place every other instructions in a while(1) loop. The "while(1)" loop is a loop that will go on forever as the PIC is on. The microcontroller will execute every instruction from the top to the bottom. When it arrives to the end of the loop, it will start again from the top. Here is a small scheme to explain that:

The first intruction is executed, the microcontroller goes to the second one (step 1). After that, it switches to the third one (step 2). It has arrived at the end of the loop, and goes back to the first instruction! (step 3). It goes like this forever as long as a current is supplied to the PIC.

Here, there is no condition for the loop, as we wrote while(1) so the loop goes on forever. But we could have added a condition like while(state == 1) for instance and the loop would have only looped while the state of the pedal is "on".

Here, the PIC is going to check continuously the state of the switch. To do that, we add a "if" statement. If the switch is pressed, the voltage of the GPIO 1 will be 0V (the switch connects the pin to ground). We have to write:

while(1) {
   if(GP1 == 0) { // if the switch is pressed
   } 
}

In human language, that will be something like "if the GPIO 1 voltage is low (= if the switch is pressed), then execute every instruction between the braces". Beware, do not forget the two "equal" signs in the "if" statement (GP1 == 0)!

OK, so if the switch is pressed, we have to change the state of the pedal. So if the pedal is on, we turn it off, and vice versa. We can use two "if" statements as well:

while(1) {
   if(GP1 == 0) { // if the switch is pressed
      if(state == 1) { // if the pedal is on...
         state=0; // ...turn it off
      } 
      if(state == 0) { // if the pedal is off
         state=1; // ...turn it on
      }  
   }
}

The variable state is changed when we press the switch!

Debouncing
Well, practically speaking, it is not that easy... When you press a switch, it does not usually provide a clean edge. There are some "bounces" and peaks, and the switch can be "on / off" very quickly when pressed, during a very short amount of time:

With the code above, the pedal would activate / inactivate really quickly in an incorrect way when we press the switch... In order to handle that, we have to "debounce" the switch, that is to say... Wait a bit!

We wait for the bounce period to be over (it is really short), and check that the switch is still on. To do that, we wait 15 milliseconds, then check that the switch is still on. To do that, we will use the __delay_ms() function, and then a if statement to see whether the switch is still pressed. This is why we had to configure the oscillator in the configuration bits!

void main(void) {
   while(1) {
      if(GP1 == 0) { // if the switch is pressed
         __delay_ms(15); // debounce
         if(GP1 == 0) {
            if(state == 1) { // if the pedal is on...
               state=0; // ...turn it off
            } 
            if(state == 0) { // if the pedal is off...
               state=1; // ...turn it on
            }
         }
      } 
   }
} 
__delay_ms(10);

There it is for debouncing!. We add 10 ms of waiting at the end of the loop. You think that we are done? Hell, no!

If you leave the code like this, if you keep your foot on the switch, the state will change really quickly from on to off! Pretty annoying... So, we have to add another "if" statement, to change the state of the pedal when the switch is released only! Before checking, we wait another 200ms (time to release the switch)

void main(void) {
   while(1) {
      if(GP1 == 0) { // if the switch is pressed
         __delay_ms(15); // debounce
         if(GP1 == 0) {
            __delay_ms(200); 
            if(GP1 == 1) { // switch is not pressed anymore
               if(state == 1) { // if the pedal is on...
                  state=0; // ...turn it off
               } 
               if(state == 0) { // if the pedal is off...
                  state=1; // ...turn it on
               }
            }
         }
      } 
   }
}
__delay_ms(10);

You can try different __wait_ms() durations here, I found that 200 ms was quite good: not too long (we do not want to wait too much to activate the pedal), and not too short (false positives)

OK, now that the pedal correctly changes its state when we press the switch, we have to specify to the microcontroller what it should do when the pedal is on or off. This part is easier. We will use a "if" statement: it checks the state of the pedal, and adjust the states of the outputs (activate or not the relay, turn the LED on or not). Write this part before the end of the while(1) loop:

if(state == 1) { // if the pedal is on
   GP5=1; // activate the relay
   GP4=0;
   GP0=1; // turn the LED on
} 
else { // else (if the pedal is off)
   GP5=0; // inactivate the relay
   GP4=0;
   GP0=0; // turn the LED off
} 
__delay_ms(10); // we wait for the PIC to change the state of each GPIO 

We add 10 ms of waiting time in the end so the PIC have time to change the state of the GPIOs: it computes quicker than changing voltages on its pins sometimes! Do not be afraid, 10 ms is really really short, and there is no way you can "feel" it while playing!

There it is! We are done !

Here is the full code:

#include <stdio.h>
#include <stdlib.h>
#include <stdint>
#include <xc.h>  
#include "header.h" // Include the header (configuration bits)

void main(void) { // main loop
   ANSEL = 0; // no analog GPIO
   CMCON = 0x07; // comparator off
   ADCON0 = 0; // ADC and DAC converters off

   uint8_t state; // variable that will define the pedal's state: on or off
   state=0; 

   TRISIO0 = 0; // GPIO 0 is an output ("0" like "Output")
   TRISIO4 = 0;
   TRISIO5 = 0;
   TRISIO1 = 1; // GPIO 1 is an input (1 like "Input") 
   GPIO=0; // Initially, all GPIOs are in a low state
   while(1) {
      if(GP1 == 0) { // if the switch is pressed
         __delay_ms(15); // debounce
         if(GP1 == 0) {
            __delay_ms(200); // switch released
            if(GP1 == 1) { 
               if(state == 1) { // if the effect is on
                  state=0; // ...turn it off
               } 
               if(state == 0) { // if the pedal is off
                  state=1; // ...turn if on
               }
            }
         }
      } 
      __delay_ms(10);
      if(state == 1) { // if the pedal is on

        GP5=1; // activate the relay

        GP4=0; 

        GP0=1; // light up the LED 

      }  

      else { // else (if the pedal is off) 

         GP5=0; // inactivate the relay 

         GP4=0; 

         GP0=0; // turn the LED off

      }
      __delay_ms(10); // we wait for the PIC to change the state of each GPIO

   }

}

Already quite complicated for such a simple idea, right?

Ok, so lets burn it in the PIC now! First, in MPLab X, click on "Build Main Project" (hammer icon):

If everything is OK, it should display "Build successful" in the lower window:

If it does not work, it should tell you where is the mistake / problem. Check everything with the provided code above. Look for forgotten ";" (most common mistake) or problems with "{}" (second most common mistake ;)

Then, open the PicKit 2 program, and have the PIC detected (cf beginning of this tutorial). You can then load the "hex" program (= hexadecimal, the only thing the PIC can understant) by clicking on "File", then "Import Hex". The compiled file is in the "MPLABXProjects" folder, then "Relay Bypass.X" folder (name of your project), then "dist", "default", and "production" folders:

It should have no problem importing it:

Change the VDD for 5V, then click on "Write" and it should be programmed to the PIC!

Your PIC has your program loaded in it!
Check on breadboard that it works:

And you can assemble a PCB! (I am working on a veroboard version of this)

On my side, I added a second switch to choose between a classic activation, or "hold". To do that, I used a second SPST switch that will define is the mode is "hold" or "permanent". I used GPIO 2 (pin number 5) as an input to sense the state of this switch.

I added another variable called "temporary" that will define if the activation is classic or in "hold" mode. I let you think a bit about it, it is a bit more complex than the above code, but you should be able to figure it out! If you want, I will post the source code one of these days :)

There it is! Your first PIC project! As you saw, it is a lot of work to get it working. It is not very complex (especially if you are already a bit familiar with coding), but doing everything right is quite long.

PICs can be used for many many different applications. For instance, you can combine them with digital potentiometers that can replace classic potentiometers, and save your presets or have a tap tempo for time-based effects. Many possibilities! Once you have done the relay bypass, you can imagine a lot of different uses for PIC in guitar pedals!

Welcome to the digital world! :)

If you have any questions or comment, post a comment and I will reply shortly :)
If this post was useful, thank me by liking the Coda Effects Facebook page! Thank you!


To go further
Explanations about why you should use relay bypass instead of 3PDT bypass (Ramble FX)
Datasheet of the PIC12F675 (132 pages pdf, good luck reading that haha!)
Good tutorial in order to start with the PIC12F675 (blinking a LED)
Video tutorial about GPIOs, very good for beginners
Video introduction about PICs and how they work
Good post about relay bypass on stompville
Another post about Relay Bypass by THCustom