Relay bypass v2 : fini les pops à l'allumage !

Vous avez aimé mon post sur le relay bypass ? En tout cas moi oui, et j'incorpore désormais ce système dans toutes mes pédales ! Ainsi, elles sont plus durables, et on évite les bruits du 3PDT. Cependant, j'ai vite remarqué une chose : le relay a tendance à "popper" beaucoup plus que le 3PDT, surtout sur des circuits avec pas mal de gain... C'est en fait logique : un relai change d'état beaucoup plus rapidement que nos gros switch mécaniques, ce qui facilite l'apparition de pop désagréables... Plus on a de gain, plus le "pop" est amplifié et donc plus on l'entendra.

J'ai donc adapté un système présenté sur Stompville qui permet de supprimer complètement ces bruits à l'enclenchements... Et voici le résultats, avec une petite vidéo avant / après :

Plutôt efficace non?

Attention : avant de vous lancer dans la lecture de cet article, je vous conseille de lire mon article sur le relay bypass afin de bien comprendre de quoi il est question ici.

Comment ça marche ?

En fait, c'est très simple : quand on switche la pédale, on coupe le son pour enlever le pop ! On va envoyer le son à la masse pour envoyer le pop à la masse, et on va ensuite laisser passer le son. On va avoir une petite période de 40 millisecondes où le son est coupé, mais je vous rassure, c'est inaudible !

Pour couper le son, on utilise un photoFET. Quésako ?
C'est un petit composant sous forme de circuit intégré qui comprend une LED et un switch avec deux MOSFET qui va laisser passer le courant quand la LED est allumée. C'est un genre de mini switch quoi ! On va utiliser ici le TLP222A qui est facilement trouvable pour pas trop cher :

On va allumer la LED avec le microcontrôleur, ce qui va envoyer le signal vers la masse. Et paf ! Couché vilain pop !

Quand le microcontrôleur est actif, le courant peut passer entre 3 et 4 et donc le signal est envoyé à la masse.
Quand le microcontrôleur est inactif : le courant ne passe pas entre 3 et 4 et donc le signal peut sortir.

Vous allez me dire : mais pourquoi on n'utilise pas ce photoFET à la place du relai ? C'est plus petit, demande moins de courant et pas mécanique, donc à priori plus résistant ! Vous avez raison, cependant, les sytèmes de switchs utilisant des FET ou MOSFET ont un souci : ils colorent le son ! Ainsi, le photoFET qu'on utilise, lorsqu'il est on, présente une résistance de 2 Ohms (ça va), et une capacitance de 130 pF (pas bon !). Si vous avez lu mon article sur les câbles, vous savez que la capacitance va dégrader votre son, 130 pF ça correspond grosso modo à 3 mètres de câble, pas terrible pour un système en true bypass ! Ici, vu qu'on l'utilise pour couper le son, ce n'est pas grave, mais pour du signal en bypass, ce serait plutôt gênant par exemple.

Voici donc à quoi ressemble le schéma du relay bypass "version 2" :

C'est donc exactement le même schéma que le relay bypass, avec l'ajout du photoFET sur la patte 5 du microcontrôleur, qui a lui même sa patte 4 reliée au niveau de la sortie du circuit.

Comment on implémente ça dans notre relay bypass ?

On utilise la patte numéro 5 du PIC pour alimenter la LED du photoFET.
Attention : la patte numéro 4 (GPIO3) est un "input only", donc on ne peut pas s'en servir pour activer le photoFET. Il faut donc impérativement utiliser la patte 5 !
Mais ne vous inquiétez pas, on va trouver une utilité pour cette patte 4 dans un article à venir...

Ouvrons donc MPLab pour y créer le header, qui va être tout à fait similaire à ce que l'on a déjà fait : il faut donc créer un nouveau projet pour le PIC12F675, et y rajouter un ficher header avec la configuration suivante :

// CONFIG
#pragma config FOSC = INTRCIO   // On utilise l'horloge interne du PIC
#pragma config WDTE = OFF       // Watchdog Timer inactif
#pragma config PWRTE = OFF      // Power-Up Timer inactif
#pragma config MCLRE = OFF      // GP3/MCLR pin est un GPIO
#pragma config BOREN = OFF      // Brown-out Detect inactif
#pragma config CP = OFF         // Pas de protection du code
#pragma config CPD = OFF        // Pas de protection de la mémoire

// Définir la fréquence de l'oscillateur
#define _XTAL_FREQ 4000000

Si vous ne vous rappelez plus ce à quoi correspond tout cela, allez relire mon article sur le relay bypass pour vous rafraichir la mémoire.

Passons maintenant au code à proprement parler. La subtilité ici va être de réussir à couper le son lors du changement d'état de la pédale en activant le photoFET.
Pour cela, on va créer une séquence lors de l'activation de la pédale :

1. Le photoFET est allumé (= le signal en sortie va vers la masse)
2. On active le relay : le "pop" est envoyé à la masse 
3. On attends un peu, histoire d'être sur que tout le bruit ait bien été envoyé à la masse
4. On éteint le photoFET : le signal sort et l'effet est actif !

Sans surprise, on va implémenter ces 4 étapes sous forme de code. On va dire au chip "dès qu'on allume l'effet, fait ces 4 étapes".

Pour cela, on va utiliser une variable "changestate" qui va dire s'il faut changer d'état ou non, qu'on va définir en plus des autres variables au début du code :

uint8_t changestate; // changement d'état (pour couper le son avec le photoFET)
changestate=0;

On lui donne la valeur de zéro initialement. Lorsque la valeur de changestate sera de 1, le microcontrolleur changera l'état de la pédale (on vers off, ou off vers on)

Typiquement, changestate sera égale à 1 quand on aura appuyé sur le switch (avec le debounce) :

if(GP1 == 0) { // si switch activé
   __delay_ms(15); // debounce
      if(GP1 == 0) {
         __delay_ms(200); // switch relâché
         if(GP1 == 1) {
            changestate = 1; // on change l'état
          }
          else {
             changestate = 0;
          }
       }
    }
    __delay_ms(10);
}

Ensuite, il va falloir préciser les 4 étapes qu'on a mentionné ci dessus lorsque changestate est égale à 1, en fonction de l'état de la pédale. Si la pédale est allumée (state = 1), on la coupe, et si elle est éteinte (state = 0), on l'allume :

if(changestate == 1) {
   __delay_ms(20);
   if(state == 0) { // on allume la pédale
      GP2 = 1; // on active le photoFET
      __delay_ms(10);
      GP0 = 1; // LED on
      GP5 = 1; // relay on
      GP4 = 0;
      __delay_ms(30); // on attend que le "pop" soit parti à la masse
      GP2 = 0; // on éteint le photoFET
      state = 1; } // on laisse la pédale allumée
   else { // on éteint la pédale : même étapes
      GP2 = 1;
      __delay_ms(10);
      GP0 = 0; // LED off
      GP5 = 0; // relay off
      GP4 = 0;
      __delay_ms(30);
      GP2 = 0;
      state = 0;
      }
   __delay_ms(20);
   changestate=0; // on reset la variable à 0
}
      
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;
 }

    

Cela ajoute un petit délai lors de l'activation (40ms), mais qui est quasiment inaudible à l'usage. Par contre on n'a plus aucun "pop", ce qui est parfaitement audible pour le coup !

Bref, ça marche vraiment super bien, et ne nécessite qu'un seul composant en plus, et on a enfin un système true bypass fiable, avec des switchs sans clic et silencieux !

Voici le code complet. N'hésitez pas à vous référer à l'article original sur le relay bypass pour bien comprendre quel est le rôle de chaque partie :

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

void main(void) {
   ANSEL = 0; // pas de port analogiques
   CMCON = 0x07; // comparator off
   ADCON0 = 0; // convertisseur AD ND off
   TRISIO0 = 0; // output LED
   TRISIO1 = 1; // input footswtich
   TRISIO2 = 0; // output TGP222A photo FET
   TRISIO5 = 0; // output relay activé
   TRISIO4 = 0; // output relay masse

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

   uint8_t state; // pédale on ou off
   state=0; // pedal off au début (lorsqu'on lui donne 9V)
  
   uint8_t changestate; // changement d'état pour l'antipop    changestate=0;

   while(1) { // boucle principale
      if(GP1 == 0) { // si switch activé
          __delay_ms(15);
          if(GP1 == 0) {
              __delay_ms(200);
              if(GP1 == 1) {
                  changestate = 1;
              }
              else {
                  changestate = 0;
              }
              }
          }
          __delay_ms(10);
      }
     
      if(changestate == 1) {
          __delay_ms(20);
          if(state == 0) { // change to on
                GP2 = 1; // PhotoFET on
                __delay_ms(10);
                GP0 = 1; // LED on
                GP5 = 1; // relay on
                GP4 = 0;
                __delay_ms(30);
                GP2 = 0; // PhotoFET off
                state = 1; }
          else { // change to off
             GP2 = 1;
             __delay_ms(10);
             GP0 = 0; // LED off
            GP5 = 0; // relay off
            GP4 = 0;
            __delay_ms(40);
            GP2 = 0;
            state = 0;
            }
          __delay_ms(20);
          changestate=0;
          }
     
        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;
        }
      }
   __delay_ms(10);
}

Et voilà ! J'espère que tout est clair, je sais que ce n'est pas un sujet facile, la bonne nouvelle c'est que vous pouvez poster un commentaire pour poser vos question !

Dans un prochain billet, nous verrons comment ajouter un mode "temporaire" qui permet d'activer l'effet temporairement au pied, comme sur mon trémolo "Montagne"

Si cette page vous a été utile, remerciez moi en likant la page Facebook Coda Effects !


Pour aller plus loin (en anglais) :
Post sur stompville qui m'a grandement aidé !
Datasheet du TLP222A, utile pour être sûr de l'orientation notamment