Relay Bypass: final code

After the crowdfunding campaign, I decided to update the relay bypass code.

Indeed, this first version was nice, but one main drawback that was feedbacked to me is that the switch was activated on release, which was not always very intuitive or easy to handle. Moreover, I wanted to add a "temporary" bypass option in the Montagne Tremolo.

Montange Tremolo Relay Bypass

In this post, I am going to explain a bit the new code and to show you how I did it.

If you have not read my post about Relay Bypass, I highly recommend you to read it before reading this post. All the basics of microcontrollers are presented there.

  Tip! The full code is available on Github. With the relayonpress.c and header.h files, you will have everything needed to code or burn chips.

If you already have a GitHub account, you can Star the project for updates, or Fork it to modify it and make your own Relay Bypass code.

Lets go!




Schematic

The relay bypass code works only when the switch is released. I also wanted to add an option to make it temporarily activable trough a switch. Finally, I wanted to add the "anti pop" system that I used before to have a totally silent bypass.

In order to do that, I added a switch, and of course the photoFET needed for the anti noise system. Here is the schematic:
Relay bypass schematic
The microcontroller is the "conductor" of the circuit.

We still use our old 12F675, the NA5WK relay and the TLG222A photoFET. The second switch (SW2) is used to choose between the normal and "temporary" mode. When the switch number 1 is activated, the microcontroller activates the LED, the photoFET to remove the "pop" noise and the relay to activate the effect.


How to code it?

Lets go to the nice part: coding!

As usual, I recommend you to use the MPLabX software (with the XC8 compiler) to write and modify the code in C, then use the PicKit2 to burn the code (in .hex format) in the PIC12F675.

For more infos, please read my original post about the Relay Bypass if you forgot all of this.


Header : configuration bits

Classic config for the PIC here.
We use the internal clock of the PIC, no protection for the code and memory and we use all the pins as GPIOs. It is the folliwing code:

// CONFIG
#pragma config FOSC = INTRCIO // Oscillator Selection bits (Internal clock)
#pragma config WDTE = OFF // Watchdog Timer Enable bit
#pragma config PWRTE = OFF // Power-Up Timer Enable bit
#pragma config MCLRE = OFF // GP3/MCLR pin function select
#pragma config BOREN = OFF // Brown-out Detect Enable bit
#pragma config CP = OFF // Code Protection bit
#pragma config CPD = OFF // Data Code Protection bit

// Define Internal clock frequency
#define _XTAL_FREQ 4000000

(it is the "header.h" file in the Github repository)


Main code

We use the MPLabX software to code in .C, which is way easier to understand and write than assembly code!

The code is separated in several parts. Let's see each one of them in detail. Do not forget that you can download the full code on GitHub.

Librairies
We have several libraries to include in the code in order to make it work, and of course the header file:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <xc.h>
#include "header.h"


Initialization
Ok, so now we are in the real part of the code :) (main() function). Lets start by initializing all the GPIOs.
We do not need any analog GPIO, so lets also turn off all the converters. We need to define which GPIOs are going to be inputs (allow to sense a 5V or 0V voltage), or outputs (sends a 5 or 0V voltage)

// Initialization
void main(void) {
  ANSEL = 0; // no analog GPIOs
  CMCON = 0x07; // comparator off
  ADCON0 = 0; // Analog to Digital and Digital to Analog convertors off
  TRISIO0 = 0; // output LED
  TRISIO1 = 1; // input footswtich
  TRISIO2 = 0; // output TGP222A
  TRISIO5 = 0; // output activation relay
  TRISIO4 = 0; // output ground relay
  TRISIO3 = 1; // input temporary switch

  GPIO = 0; // set outputs as low level (0V)

It looks a lot like the old code we already wrote before. We added one input to have the second switch that allows us to choose between temporary and normal mode. Finally, we reset all the GPIOs to 0 when the pedal is powered.


Variable definition
We need to define several integer variables. A first "state" variable defines the state of the pedal (1="on", 0="off"), the "changestate" variable is used to change the state of the pedal (useful to avoid the noise when the pedal changes of state)

There are 2 new variables compared to the previous code: "temporary" which defines the activation mode of the pedal (normal or temporary), and "press_switch" that is used as a counter to know when the switch is pressed and allow the activation when we press the switch (and not on release)

  // Variables definition
  uint8_t state; // on-off state of the pedal (1 = on, 0 = off)
  state = 0;

  uint8_t changestate; // to change status of the pedal
  changestate = 0;

  uint8_t temporary; // define the mode of the pedal : classic or temporary activation
  temporary = 0;

  uint8_t press_switch; // variable to detect if the switch is pressed
  press_switch = 0;

All these variables are initially set to 0, which defines the following state of the pedal when powered: "off" state (state = 0), no state change (changestate =0), standard activation mode (temporary = 0) and the switch is considered not pressed of course (press_switch = 0). This variables will be detailed below


Temporary / Normal mode
The temporary variable is used to define whether we are in temporary or normal mode. Depending on the state of an external switch, the microcontroller can sense the state of the swtich (it is linked to ground - 0V - or to 5V). It can then change the value of the temporary variable.

  // Main loop
  while(1) {
    if(GP3 == 0) { // By default: normal mode
      temporary = 0;
    }
    else { // If the "hold" mode is activated through the switch
       temporary = 1;
    }


Normal mode : switch detection
This part detects when the switch is activated. Here is the code:

    // Normal mode
    if(temporary == 0) {
       if(GP1 == 0) { // footswitch pressed
         __delay_ms(15); // debouncing
         if(GP1 == 0) {
         press_switch = press_switch + 1; // switch is on
       if(press_switch>10) {
         press_switch = 10; // max value for press_switch
       }
      }
    }
        if(press_switch == 1) { // switch is pressed : lets turn the pedal on or off
          changestate = 1;
          press_switch = 2; // avoid bug if press_switch stays at 1
        }
        if(GP1 == 1) {
          __delay_ms(15); // debouncing
          if(GP1 == 1) {
            press_switch = 0;
          }
        }
      }

When you press the switch, there is first a debouncing to check that it is indeed a clic on the switch, using a simple __delay_ms(15). Finally, if the user have indeed pressed the switch, we increment the press_switch variable.

The next bits of the code define a maximum of 10 for press_switch. Indeed, if you do not add this part, the value of press_switch can increase way too much and cannot even be stored in the PIC memory!

When press_switch is equal to 1, changestate is changed to 1. The microcontroller knows that he has to change the state of the pedal now! Incrementing press_switch to 10 prevents the pedal to change state all the time if you press the switch for a long time... Similarly, press_switch is changed to 2 immediatly after setting changestate to 1 to avoid this.

Finally, when the switch is released (GP1 == 1), press_switch is reset to 0.


Temporary activation mode
This part works really similarily to the part shown above, except that the state of the pedal is reset to 0 (off) when you release the switch: temporary activation mode!

      // Temporary mode
      if(temporary == 1) {
        if(GP1 == 0) { // if switch is pressed : temporary activation
          __delay_ms(15); // debouncing
          if(GP1 == 0) {
            press_switch = press_switch + 1; // switch is on
            if(press_switch>10) {
              press_switch = 10; // max value for press_switch
            }
          }
        }
        if(GP1 == 1) { // if switch is not pressed, turn it off
          __delay_ms(15); // debouncing
          if(GP1 == 1) {
            state = 0;
            press_switch = 0;
          }
        }
        if(press_switch == 1) {
          changestate = 1; // if switch is pressed, turn the pedal on
          press_switch = 2; // avoids bug
        }
      }



Change the state of the pedal
This step changes the state of the pedal (on to off or on to off). It is during this step that the photoFE is activated.
The code is totally similar to what I have presented in my post about noiseless relay bypass.

      // Changing state of the pedal
      if(changestate == 1) {
        if(state == 0) { // change to on
          GP2 = 1; // photoFET on
          __delay_ms(20);
          GP0 = 1; // LED on
          GP5 = 1; // relay on
          GP4 = 0;
          __delay_ms(20);
          GP2 = 0; // photoFET off
          state = 1;
        }
        else { // change to off
          GP2 = 1;
          __delay_ms(20);
          GP0 = 0; // LED off
          GP5 = 0; // relay off
          GP4 = 0;
          __delay_ms(20);
          GP2 = 0;
          state = 0;
        }
      __delay_ms(10);
      changestate=0; // reset changestate
    }

It causes a very slight delay for the activation of the pedal (40ms). However, practically speaking, you really cannot tell!


On or off state of the pedal
Once the pedal has changed of state (on or off), we maintain the pedal in this state with this few lines of code:

    // To let the pedal in the good state (on or off)
    if (state == 1) { // effect on
      GP0 = 1; // LED on
      GP5 = 1; // relay on
      GP4 = 0;
    }
     else { // effect off
      GP0 = 0; // LED off
      GP5 = 0; // relay off
      GP4 = 0;
    }
  }
}



Full code

Here is the full code of the project (you can read it directly on GitHub):

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <xc.h>
#include "header.h"

// Initialization
void main(void) {
  ANSEL = 0; // no analog GPIOs
  CMCON = 0x07; // comparator off
  ADCON0 = 0; // Analog to Digital and Digital to Analog convertors off
  TRISIO0 = 0; // output LED
  TRISIO1 = 1; // input footswtich
  TRISIO2 = 0; // output TGP222A
  TRISIO5 = 0; // output activation relay
  TRISIO4 = 0; // output ground relay
  TRISIO3 = 1; // input temporary switch

  GPIO = 0; // set outputs as low level (0V)

  // Variables definition
  uint8_t state; // on-off state of the pedal (1 = on, 0 = off)
  state = 0;

  uint8_t changestate; // to change status of the pedal
  changestate = 0;

  uint8_t temporary; // define the mode of the pedal : classic of temporary activation
  temporary = 0;

  uint8_t press_switch; // variable to detect if the switch is pressed
  press_switch = 0;

  // Main loop
  while(1) {
    if(GP3 == 0) { // By default: normal mode
      temporary = 0;
    }
    else { // If the "hold" mode is activated through the switch
       temporary = 1;
    }

    // Normal mode
    if(temporary == 0) {
       if(GP1 == 0) { // footswitch pressed
         __delay_ms(15); // debouncing
         if(GP1 == 0) {
         press_switch = press_switch + 1; // switch is on
       if(press_switch>10) {
         press_switch = 10; // max value for press_switch
       }
      }
    }
        if(press_switch == 1) { // switch is pressed : lets turn the pedal on or off
          changestate = 1;
          press_switch = 2; // avoid bugs if press_switch stays at 1
        }
        if(GP1 == 1) {
          __delay_ms(15); // debouncing
          if(GP1 == 1) {
            press_switch = 0;
          }
        }
      }

      // Temporary mode
      if(temporary == 1) {
        if(GP1 == 0) { // if switch is pressed : temporary activation
          __delay_ms(15); // debouncing
          if(GP1 == 0) {
            press_switch = press_switch + 1; // switch is on
            if(press_switch>10) {
              press_switch = 10; // max value for press_switch
            }
          }
        }
        if(GP1 == 1) { // if switch is not pressed, turn it off
          __delay_ms(15); // debouncing
          if(GP1 == 1) {
            state = 0;
            press_switch = 0;
          }
        }
        if(press_switch == 1) {
          changestate = 1; // if switch is pressed, turn the pedal on
          press_switch = 2; // avoids bug
        }
      }

      // Changing state of the pedal
      if(changestate == 1) {
        if(state == 0) { // change to on
          GP2 = 1; // photoFET on
          __delay_ms(20);
          GP0 = 1; // LED on
          GP5 = 1; // relay on
          GP4 = 0;
          __delay_ms(20);
          GP2 = 0; // photoFET off
          state = 1;
        }
        else { // change to off
          GP2 = 1;
          __delay_ms(20);
          GP0 = 0; // LED off
          GP5 = 0; // relay off
          GP4 = 0;
          __delay_ms(20);
          GP2 = 0;
          state = 0;
        }
      __delay_ms(10);
      changestate=0; // reset changestate
    }

    // To let the pedal in the good state (on or off)
    if (state == 1) { // effect on
      GP0 = 1; // LED on
      GP5 = 1; // relay on
      GP4 = 0;
    }
     else { // effect off
      GP0 = 0; // LED off
      GP5 = 0; // relay off
      GP4 = 0;
    }
  }
}

  Tip! The full code is available on Github. With the relayonpress.c and header.h files, you will have everything needed to code or burn chips.

If you already have a GitHub account, you can Star the project for updates, or Fork it to modify it and make your own Relay Bypass code.


There it is! If you liked this post, like the Coda Effects Facebook page or the Coda Effects Instagram for more follow up about the blog.
If you have any question or remark, post a comment!
Previous
Next Post »
19 Comment
avatar

Benoit, you are awesome!

Your relay bypass works like a charm w no noise at all.

I've made a diy-ish layout for it and posted on FSB if you don't mind
Link: http://freestompboxes.org/viewtopic.php?p=262810#p262810

My regards

Answer
avatar

This is great! Thank you, very nice initiative!
I'll try to help people on this forum topic, I have not visited freestompboxes for a while these days...

Answer
avatar

I'm sorry, I did not notice that attachments on both fsb and madbean forum are only visible for registered users.

I've made a short post on imgur, hope this would help the diy community: http://imgur.com/a/OFhf4

Thanks for sharing your hard work with us, you deserve more credit.

My regards,

Answer
avatar

Very nice! I really like the fact that you made it etchable. Could be nice to do a vero version as well.
Can I place it in the blog post?
I will of course credit you for the design.

Answer
avatar

Of course you can, it would be super cool.
But I still think that my layout needs some tweaks and optimization. Can you give me some time to make sure it is compact and usable enough?

Answer
avatar

Of course! Let me know when you are satisfied with your design :)
I'll work on a double sided version

Answer
avatar

Merci pour l'article.
Thanks for the article.
Did something similar but using assembly instead of C.
Got everything to fit on a 10F200.
Used internal pull-up resistors and also used the SLEEP capability to save power.

One suggestion, instead of using two pins to activate your relay, put one side of the relay directly to the GND and use a transistor driver on GP5 to activate your relay. That will free GP4. Then you can use GP4 and GPO to turn on a 2 colors 2 pin LED. If GP4 is high and GP0 in low then the LED is one color, if GP4 is low and GP0 high then the LED is another color. That way you could flip the color af the LED to show is you are in Latching mode or in Momentary mode.

Don't know if this is clear? I'm french so if you want to talk about this in french. I'm alparent on the Madbean and DIYStompbox forum.

Answer
avatar

Very clear!
And very good idea by the way, I should definitely try it

Answer
avatar

Hi Benoit,
Is there somewhere you would recommend to find the relay and pic in Europe?
I'm looking for a single shop where I can find both, but that's not that easy it seems.

Answer
avatar

Hi Matthew,

You could checkout UK-Electronic:

http://www.uk-electronic.de

PIC:
http://uk-electronic.de/onlineshop/product_info.php?products_id=3028&osCsid=ad83064c6d9ff30eafde0473504f0786

Relay:
http://uk-electronic.de/onlineshop/product_info.php?products_id=3486&osCsid=ad83064c6d9ff30eafde0473504f0786

Hope this helps!

Regards,

Arjan Kingma
FWS Pedals Germany

Answer
avatar

any chance that a different model of the photocell works? the ones ive found of those you stated are expensive where ive found them.

Answer
avatar

Hi! You can buy them cheaply on aliexpress

I've bought myself a couple of dozens here, they are all completely functional: https://aliexpress.com/item/Free-shipping-10pcs-lot-TLP222A-P222A-DIP-4-new-original/32675517837.html?spm=2114.13010608.0.0.A6e2jI

Answer
avatar

thanks a lot! have you tried the above code with 100% sucess btw?

Answer
avatar

Hi Benoit,

I've just found another optocoupler, that might be used in this circuit for muting
It's called CPC1017N
It has 16ohm on resistance and 1pf capacitance which is very very low.

Answer
avatar

Great indeed! I will definitely check that out!

Answer
avatar

Hello !

It is also possible to find the relay on banzai music : https://www.banzaimusic.com/Takamisawa-NA05W-K.html

The photoFET is harder to come by, I usually order it on mouser.com when I order other stuff (free delivery from 50€)

Answer
This comment has been removed by the author. - Hapus
avatar

Just finished a vero layout for this and it's VERIFIED.
https://goo.gl/DP2Cbi

Answer