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.

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:

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!