Relay bypass : mise au point et fonctionnement

Vous avez peut être déjà entendu parler du "relay bypass", ou même déjà utilisé ce système sans le savoir. Il s'agit d'un système true bypass, mais assez différent du système utilisant un switch 3PDT. Au lieu d'utiliser un switch mécanique, on va utiliser un microcontrôleur, un relai et un switch sans clic.
Relay Bypass Pedal DIY Soft Switch PCB
 Alors vous allez me dire : pourquoi ?

Comme vous le savez peut être, le switch 3PDT est LA première cause de défaillance des pédales d'effet. Ces switchs sont relativement peu solide (relativement, parce qu'on les martyrise quand même pas mal sur scène), et ne tiennent en théorie que 30 000 cycles d'activation pour les meilleurs d'entre eux. Avec le relay bypass, on va utiliser un relai qui va jouer le rôle de connecteur mécanique. Les relais durent entre 10 et 100 millions de cycles ! On a donc un système bien plus résistant dans le temps !

De plus, le switch qu'on va utiliser est moins bruyant (pas de "clic" lorsqu'on l'active) et dure aussi plus longtemps qu'un 3PDT, 50 000 cycles généralement. Ils sont aussi bien plus faciles à remplacer puisqu'il n'y a que 2 connections à faire !

On va voir dans cet article comment cela fonctionne, et comment coder le microcontrôleur nécessaire pour que cela fonctionne. Accrochez vous ça va être long !



Sommaire





Comment ça marche le relay bypass ?


Un relai fonctionne un peu comme un interrupteur, activé par un courant. Il comporte une bobine : quand elle reçoit un certain courant, elle va activer le switch interne du relai. Sur ce symbole :
Relay Symbol
La bobine est représentée (le rectangle avec une diagonale), le switch interne par un symbole de switch. Quand on fournit un courant du coté + de la bobine, on active le switch, qui change de coté.

Les relay existent en version DPDT, ce qui va nous permettre de faire switcher le signal : en mode "normal" on sera en bypass, et quand on active au pied, l'effet sera activé.

Comment faire maintenant pour que le relay soit activé au bon moment, ou pour allumer la LED puisque les relais n'existent pas en 3PDT ? On va utiliser un microcontrôleur. Un microcontrôleur est un chip numérique à 8 pattes, il s'agit en fait d'un ordinateur miniature ! On peut y stocker un code qui va lui dicter précisément quoi faire. Ici, on va lui dire en gros : "active le relai quand j'appuierai sur le switch, et allume la LED si le circuit est on". Ainsi c'est lui qui va activer le relai en envoyant un courant qui va activer le relai.

Voilà à quoi ça ressemble dans une pédale commerciale (chez Dr Scientist) :
Dr Scientist Relay bypass circuit
Le switch est relié au microcontrôleur qui va "capter" quand le switch est pressé, puis va activer le relai et la LED : l'effet est activé !

Ok, ça a l'air tout simple comme ça, vous verrez qu'en pratique c'est un peu plus complexe !




Schéma du circuit


Voici le schéma du circuit qu'on va réaliser :
Relay bypass schematic
Le microcontrôleur est un PIC, le PIC12F675. Les PIC sont un type de microcontrôleurs très répandu, produit par MicroChip. Il y a plein de PIC différents avec un nombre de pattes différents, des options en plus (convertisseurs analogique / digital...etc). Le PIC12F675 est un chip 8 bits très complet, pas très cher et petit (8 pattes). Il conviendra parfaitement pour notre utilisation !
Microchip PIC12F675
On peut aussi utiliser un ATtiny85 qui peut fonctionner avec Arduino, ou d'autres types de microcontrôleurs (il y en a plein !). J'ai choisi le PIC12F675 car il est très documenté, et peut être codé en C, qui est un langage assez simple et fonctionnel.

Comme vous pouvez le voir sur le schéma, il faut lui fournir 5V régulés sur la patte 1, et connecter à la masse la patte 8. Pour fournir les 5V régulés, on utilise un régulateur de tension, comme pour la Belton brick qu'on a déjà vu avec les réverb. Un 78L05 fait très bien l'affaire. Un condensateur C1 va éviter les variations brutales de tensions liées à l'alimentation.

Après, on connecte le relai comme il faut : les switchs sont câblés comme un 3PDT : le signal rentre, puis soit il est connecté directement à la sortie (sur le schéma il fait 9, 10, 3 puis sort par 4), soit on envoie le signal vers l'effet (SND), puis on envoit le signal de sortie de l'effet (RTN) vers la sortie de l'effet (OUT). On rajoute une diode de protection qui évite des variations des problèmes liés aux bobines (lorsqu'on coupe le courant, elles peuvent générer un voltage qui abimerait le reste du circuit...)



Le microcontrôleur


Le microcontrôleur, comme les OP amps, a une patte connectée à l'alimentation (5V ici), et une connectée à la masse.

Chaque patte restante du microcontrôleur (les pattes numéro 2, 3, 4, 5, 6 et 7) peut être utilisée soit comme une entrée, soit comme une sortie. On les appelle "GPIO" (General Purpose Input / Output) et on peut les configurer comme on veut avec le code qu'on va inclure dans le microcontrôleur :
  • Entrée (input) : le microcontrôleur va "sentir" ce qu'il se passe au niveau de la patte : valeur d'un voltage, switch pressé ou non ...etc
  • Sortie (output) : le microcontrôleur va envoyer un courant depuis cette patte vers les composants qui sont connectés à cette patte.
Ici, on commence à se douter ce qu'on va faire : la patte connectée à la LED va être une sortie, celles connectées au relai aussi, et celle qui va "sentir" le switch va être une entrée. On a donc 1 entrée (patte 6) et 3 sorties (pattes 2, 3 et 7)

ATTENTION : pour que cela soit plus logique et plus drôle (ironie...), le numéro des GPIO est différent de celui des pattes... Voici un petit schéma :
PIC12F675 GPIO relay bypass
La patte 2 est donc le GPIO numéro 5, la patte 6 est le GPIO numéro 1...etc. Dans le programme qu'on va écrire, il faudra nommer les GPIO en fonction de ces numéros et pas du numéro des pattes ! Vous commencez à entrevoir les subtilités qui nous attendent...

Bien !

Chaque entrée ou sortie (chaque GPIO) peut être configurée comme analogique ou digitale :
  • Analogique : on peut utiliser un convertisseur Analog to Digital (ADC), pour pouvoir "lire" la valeur du voltage de 0 à 255 (le PIC12F75 est en 8 bits, mais il existe des chips 16 ou 32 bits qui peuvent lire plus de valeurs différentes !). A noter qu'on peut aussi utiliser un convertisseur Digital to Analog (DAC) pour envoyer un voltage précis (entre 0 et 5V, avec 256 échelons) sur une sortie.
  • Digitale : on peut lire soit une valeur "haute" (high) ou une valeur "basse" (low). Cela correspond à des 1 ou 0 si vous voulez. Dans notre cas, la valeur haute sera de 5V, et basse de 0V.
Ici, on ne va pas s'embêter : on enverra 5V au relai et à la LED quand l'effet sera activé, et 0V quand il sera off. Les sorties seront donc configurées comme digitales.
Pour sentir le switch, on a pas besoin d'avoir  un nombre de valeur précise, ce sera du on / off. On peut donc mettre l'entrée comme digitale aussi.

On verra tout à l'heure plus en détail comment ça se passe au niveau du code.




Le relai


Il existe énormément de modèles de relais, qui acceptent des tensions différentes. Ils ont aussi des tailles très différentes, et des formes différentes. Les relais Reed ressemblent à des circuits intégrés, les relais classiques à des gros cubes, avec plus ou moins de pattes... Il leur faut une puissance plus ou moins importante pour que la bobine soit activée. Voici un exemple de quelques relais :
Relays types

On a donc vu qu'on allait utiliser les états hauts ou bas du microcontrôleur pour activer le relai. On va donc fournir 5V. Il nous faut donc un relai qui peut s'activer avec une tension de 5V. En fait, on a plusieurs conditions à respecter.

Pour notre utilisation il nous faut un relai :
  • De petite taille : on ne veut pas s'encombrer d'un relai qui prendrai la moitié du boitier, et si ça peut rentrer dans du 1590A, ce serait un gros plus
  • Activé par une tension de 5V : ce qui correspond à la valeur "haute" en sortie d'une patte du microcontrôleur ("valeur haute d'une sortie numérique d'un GPIO" si on veut se la jouer un peu)
  • Avec une faible puissance d'activation : le microcontrôleur ne peut pas délivrer de grosses intensités en sortie. Généralement, on a 20 mA, ce qui nous fait une puissance de 100mW. A noter qu'on peut utiliser un transistor pour amplifier le courant.
  • en DPDT : on veut pouvoir switcher input et output, il nous faut donc un DPDT.
  • Pas trop cher : bah oui, on n'a pas envie que ce système coute 30 fois plus cher qu'un 3PDT. Étant donné que ce système dure à peu près 2 à 3 fois plus longtemps (et plus facile à remplacer), on va tabler sur un cout total de 3 fois un bon 3PDT, c'est à dire une dizaine d'euros au total. Le switch soft coute environ 3 euros, ça nous laisse donc 7 euros pour tout le reste !
  • Pas de composant de surface : pour que cela soit plus facile à assembler.

Il a donc fallu fouiner dans toutes les datasheets de tous les relais pour trouver le compromis parfait...

And the winner is...

Le Takamisawa NA05W-K ! De petite taille, pas cher (on en trouve à moins de 2 euros), 140 mW d'activation (un transistor devrait donc permettre de l'activer sans souci), DPDT... Bref, parfait pour notre utilisation.
J'avais aussi repéré le Panasonic TQ2-L - 5V, en 140 mW aussi, mais un peu plus gros (plus large), et surtout plus cher (autour de 4 euros). C'est aussi un relai de type "latching" (ne consomme de l'énergie que lorsqu'il change de position), pas idéal car impossible de switcher vers le bypass si la pédale n'est pas alimentée par exemple.




Le code du relay bypass


Bon, on sait comment on va faire, avec quels composants, il ne reste "plus qu'à" coder le PIC et à réaliser le circuit imprimé !


Interface PIC / PC
Pour pouvoir coder et graver le PIC, il va nous falloir une interface entre notre PC et le PIC, qui va permettre de transférer les informations depuis le PC (le code qu'on aura tapé) vers le PIC.

Pour les PIC, c'est extrêmement simple : MicroChip vend une interface appelée PicKit2 (il y a une version 3, mais plus chère, alors que la 2 fonctionne à merveille). Je vous conseille d'acheter un adaptateur avec ce qui vous permettra de moins galérer qu'avec une breadboard.

Je vous conseille de passer par ebay, en tapant "PicKit 2", on trouve très vite son bonheur, pour un prix modique (généralement, autour de 20 euros). Pensez que cela pourra vous servir pour plein d'autres projets et qu'il s'agit donc d'un petit investissement, de la même manière qu'acheter un fer à souder !

Voici le mien (le PicKit2 est en rouge, et j'utilise un adaptateur) :
PicKit2

A noter qu'il existe des "clones" qui émulent le PicKit. C'est un peu moins cher, mais je vous déconseille afin d'éviter les galères de compatibilités entre logiciels et autre fun dans le style...

Au niveau de votre PC, MicroChip propose aussi un logiciel gratuit (enfin dans sa version simplifiée qui nous suffit) qui s'appelle MPLab X, qui va nous permettre de coder notre PIC en C. On échappe ainsi au langage assembleur, qui est vraiment complexe. Il faudra aussi télécharger le compilateur XC8 (dans l'onglet "download" en bas). Pour le transfert de données en lui même (quand on va graver notre PIC), il faut le logiciel associé au PicKit2, lui aussi produit par MicroChip.

Vous pouvez installer MPLab et PicKit2, et on va connecter le PIC au PC en utilisant l'adaptateur. A noter que tout est indiqué au dos pour un PIC à 8 pattes. Il faut bien placer les jumpers comme indiqués afin qu'il soit reconnu :
La broche VPP / MCLR (celle du bas sur les 6 broches en haut à droite) doit être connectée sur la broche du PicKit2 qui a une flèche. Connectez alors le PicKit2 à votre ordinateur avec le câble USB.

Normalement, si vous ouvrez PicKit2, il devrait détecter le PICkit ("PICkit 2 connected") :
PICKit2 programmer
Si cela ne marche pas, déconnectez / reconnectez le PIC kit, ça peut parfois être un peu difficile, mais cela devrait marcher rapidement. Tous les "3FFF" dans l'écran du bas représentent la mémoire du PIC (en hexadécimal) Quand on branchera notre PIC, on pourra voir notre code gravé dedans en hexadécimal !

Ensuite, on va essayer de détecter le PIC. Pour cela, il faut choisir le type de PIC qu'on utilise. Ici ce sera : "Device Family", puis "Midrange", puis "Standard" :
PICKit2 programmer
Enfin, en cliquant sur "Read", il devrait être détecté par l'ordinateur. A noter qu'il est parfois un peu lent à la besogne, il ne faut pas hésiter à déconnecter / reconnecter le PIC ou l'adaptateur quand il ne trouve pas. Au bout d'un moment vous devriez avoir ça :
PICKit2 programmer

Voilà, on peut maintenant passer au code en lui même ! Fiouu !


Configuration du PIC
Avant toute chose, il faut configurer le PIC pour lui dire de quoi on aura besoin, quel est le statut de chaque patte etc... Comme ça à chaque fois qu'on l'allumera (dès qu'on lui fournit un courant), il saura quoi faire.

Il ne faut pas négliger cette étape, elle est extrêmement importante. Et si vous ne la faites pas, ça ne marchera pas de toute façon ! Na ! Il va falloir donc ouvrir MPLAB X.

Si jamais vous êtes paumé au cours de cette étape, vous pouvez aussi vous aider avec cette vidéo, en anglais, avec un bon accent indien, pas facile, mais on peut suivre !

Pour cela, faites "File",  "New Project", "Sandalone Project" (cliquez sur "Next"). Il va falloir ensuite choisir le type de PIC. Tapez simplement le nom du PIC, ici PIC12F675 :
MPLab X New project
Après on vous demande choisir un header, laissez sur "none". On vous demande de choisir le "tool" qui est en fait l'interface PIC / ordinateur, donc le Pic Kit 2 ici :
MPLab X New project
On vous demande de choisir ensuite le compilateur, choisissez XC8, cliquez sur "next", puis donnez le nom que vous voulez à votre projet, genre "relay bypass". (à tout hasard :) ), puis cliquez sur "Finish". Ca va vous créer un dossier à gauche portant le nom de votre projet, avec différents sous dossiers :
MPLab X New project

Allez, maintenant que tout est en place, on passe au code !

Il faut donc configurer le PIC tout d'abord. Pour cela, il faut créer un fichier dans le header ("header file"). Pour cela, cliquez sur "New", "File". Une fenêtre va s'ouvrir, sélectionner le dossier "C" (language), puis "header file" :
MPLab X New project
 Ensuite, entrez le nom du fichier ("header", ce sera très bien), puis cliquez sur "Finish". Le fichier "header.h" devrait apparaître dans le dossier "header" :
MPLab X New project
En bas à droite, vous pouvez cliquer sur "Configuration bits" pour choisir la configuration du PIC :
MPLab X PIC12F675 configuration bits
Dans ce menu, on a toutes les options possibles pour la configuration du PIC : oscillateur, protection du code... etc. Voici les différentes options et ce que l'on va mettre :
  • Oscillator Selection bits : il s'agit de l'horloge du PIC. Elle peut être soit externe, soit interne si le PIC en a un. Ici, le PIC12F675 a une horloge interne, on va donc l'utiliser en mettant "INTRCIO". On va avoir besoin de l'horloge interne ici pour définir des temps d'attente (40 millisecondes par exemple)
  • Watchdog timer : non nécessaire ici : "OFF"
  • Power Up Timer enable bit : permet d'ajouter un délai de 72ms lors de l'allumage. Non nécessaire ici : on met "OFF"
  • GP3 / MCLR pin function select : la broche 3 du PIC peut servir comme "bouton reset" (=MCLR) ou comme un GPIO classique. Ici, on n'a pas besoin du mécanisme de "reset", donc on met "OFF" pour transformer cette broche en GPIO classique.
  • Brown-out Detect Enable bit : le "Brown Out" est un petit circuit comparateur intégré au PIC qui permet de vérifier que le voltage fourni au PIC est bon, et ainsi éviter des problèmes de corruption de la mémoire si le voltage est trop bas. Cependant, quand il est activé, le PIC consomme plus. De toute manière, vu qu'on n'utilise pas la mémoire interne du PIC ici, on va l'inactiver. "OFF" aussi !
  • Code protection bit : voulez vous que votre code soit visible par les autres ou non ? Si vous voulez protéger votre code (utile pour une pédale commerciale), mettez "ON", sinon pas besoin. Ici, vu que le code est publié sur ce blog, on va mettre "OFF" bien sûr :)
  • Data code protection bit : les PIC ont une petite mémoire flash intégrée (les EEPROMs); Vous pouvez protéger cette mémoire pour que personne ne puisse voir ce qu'il y a dedans. Ici on n'utilise même pas cette mémoire donc vous pouvez laisser "OFF".
Une fois qu'on a défini tout ça (pour résumer : "INTRCIO", puis "OFF" partout), on peut cliquer sur le gros bouton "Generate Source Code to Output". Il devrait maintenant vous afficher un code dans un onglet "output". Sélectionnez et copiez ce code :
MPLab X PIC12F675 configuration bits
Normalement, vous avez cela dans la fenêtre centrale :
MPLab X PIC12F675 configuration bits
Sélectionnez tout à partir de #ifndef, et supprimez tout (oui oui). Puis collez le code qu'il vient de vous générer. Vous devriez avoir cela :
MPLab X PIC12F675 configuration bits
On a quasiment fini. Dernière chose à rajouter : il faut lui préciser la fréquence de l'horloge interne. Ici, on utilise une horloge interne à 4 MHz. On va donc rajouter une ligne de commande :

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

Le symbole "//" vous permet de rajouter des commentaires, très utile pour savoir à quoi sert chaque ligne de commande, je vous conseille d'en mettre partout !
Et voilà, terminé pour la configuration ! Sauvegardez tout ça, on peut passer au code maintenant (fiouuu)


    Code pour sentir le switch et activer le relai
    Il va falloir créer le fichier contenant le code C principal. Pour cela, on clique sur " File", puis "New File". Cliquez sur le dossier C (on va coder en C), puis choisissez le type de fichier "C Main File" :
    MPLab main file
    Choisissez ensuite le nom du fichier, puis cliquez sur "Finish". Ensuite, placez le fichier dans le dossier "Source Files" du projet :
    MPLab main file

    Normalement, vous devriez avoir cela maintenant dans la fenêtre principale :
    MPLab main file
    Supprimez toute la partie en dessous de #include, et rajoutez cette ligne de code qui permet de tenir compte de la configuration qu'on a programmée (mettez bien le bon nom de fichier), et de rajouter deux librairies nécessaires (stdint.h va permettre de gérer des variables, et xc.h de rendre notre code compatible avec le compilateur xc8) :

    // Librairies supplémentaires nécessaires
    #include <stdint.h>
    #include <xc.h>
    // Inclut la configuration
    #include "header.h"
     

    Vous  devriez avoir cela maintenant :
    Configuration bits final


    Bon, on peut maintenant commencer à réfléchir à ce qu'on veut au niveau du code en lui même:
    • quand le switch est pressé, il faut voir dans quel état est la pédale (on ou off), et passer à l'état contraire : on active si la pédale était off, et on désactive si la pédale était on
    • quand la pédale est on, il faut que le relay soit tout le temps activé,  et la LED aussi, pas que quand on appuie.
    On va donc maintenant passer à la boucle principale qu'on appelle void main(). Tout le code qui doit être effectué par le PIC est inclus dans cette boucle.

    void main(void) {
    }

    On va donc utiliser une variable qui va "retenir" l'état de la pédale. Ici je l'ai appelée "state". Elle peut prendre deux valeurs : 1 (la pédale est "on") et 0 (la pédale est "off")
    Au départ, on peut mettre state = 0. Par définition, l'effet sera éteint quand on lui fournit un courant.

    uint8_t state; // variable qui définit l'état de la pédale
    state=0;

    Ici, on définit la variable "state" qui est un entier non signé = entier positif ("u" = unsigned = non signé = positif, "int" = integer = entier). Ne pas oublier le point virgule à la fin de chaque instruction !

    Comme vous le voyez, on peut mettre des commentaires dans son code en utilisant le double slash "//". Je vous conseille vivement d'en mettre beaucoup pour vous aider à vous y retrouver.

    Il nous faut ensuite ajouter quelques instructions pour spécifier au PIC quoi faire des différents appareils internes dont il dispose. Ici comme on n'a pas de valeurs analogiques, on va désactiver les convertisseurs ADC et DAC. On va aussi désactiver le comparateur dont on n'a pas besoin (permet de comparer les voltages entre 2 pattes différentes). Pour cela, on écrit :

    ANSEL = 0; // pas de port analogiques 
    CMCON = 0x07; // comparateur off 
    ADCON0 = 0; // convertisseur ADC et DAC off

    On va ensuite définir le rôle de chaque GPIO : on définit lesquels sont des entrées, lesquels sont des sorties. Ici, on avait dit que les GPIO 0, 4 et 5 étaient des sorties, et le 1 une entrée.

    TRISIO0 = 0; // la patte 7 est une sortie (0 comme "Output")
    TRISIO4 = 0;
    TRISIO5 = 0;
    TRISIO1 = 1; // la patte 6 est une entrée (1 comme "Input")
    GPIO=0; // on met tous les GPIO en état bas (0V) au démarrage

    On va ensuite placer toutes nos instructions dans une boucle while(1). Toutes les instructions dans cette boucle vont se répéter durant toute la durée où le PIC est allumé, en s'effectuant une à une dans l'ordre où elles sont écrites. Voici un petit schéma pour vous expliquer :
    while loop

    La première instruction est exécutée, on passe à la deuxième (1), puis à la troisième (2). Une fois arrivé à la fin de la boucle, on revient au début (3), et c'est reparti pour un cycle.

    Comme on n'a pas mis de condition pour la boucle, on a écrit while(1), donc la boucle s'exécute à l'infini, mais on aurait pu écrire while(state==1) par exemple pour que la boucle n'ai lieu uniquement quand la pédale est on par exemple.

    Ici, le PIC va analyser en continu l'état du switch. Pour cela, on va mettre une condition "if" (= "si"). Sur le schéma ci dessus, vous voyez que si le switch est pressé, la tension sera de 0V (on connecte la patte à la masse). Il suffit donc d'écrire :

    while(1) {
       if(GP1 == 0) { // si le switch est pressé
       } 
    }

    On peut traduire ce bout de code par "si la tension au GPIO 1 est basse (= 0V), alors, exécute tout ce qui se trouve entre les {}". Attention au "==" !

    Maintenant, il faut changer l'état de la pédale : si le switch est pressé et que la pédale est on, il faut la faire passer en off, et vice versa. On va donc changer l'état de la variable "state".


    while(1) {
       if(GP1 == 0) { // si le switch est pressé
          if(state == 1) { // si la pédale est on
             state=0; // on la fait passer off
          } 
          if(state == 0) { // si la pédale est off
             state=1; // on la fait passer on
          }  
       }
    }

    On a donc fait changer l'état de la pédale quand le switch est pressé !

    Le "debouncing"
    Alors, ce serait trop facile si c'était aussi simple... En pratique, on a un problème car l'activation d'un switch est rarement parfaite. Lorsqu'on appuie sur un switch il peut passer d'un état on à off plusieurs fois très très rapidement. On a des petits pics d'activation / inactivation pendant un temps très court :
    Debouncing
    Si on laissait le code tel quel, on aurait des "bugs" : la pédale s'activerait sans raison ou s'inactiverai de manière incorrecte... Il faut donc gérer cela. Pour permettre cela, on va juste... Attendre !

    On attend que la période de "bounce" soit passée (elle est très courte), et on vérifie que le switch est toujours activé. Pour cela, on ajoute un __delay_ms(15) (on demande d'attendre 15 millisecondes), puis on remet une boucle if pour revérifier que le switch est bien activé. C'est pour cela qu'on a du bien configurer l'horloge interne au début !

    void main(void) {
       while(1) {
          if(GP1 == 0) { // si le switch est pressé
             __delay_ms(15); // debounce
             if(GP1 == 0) {
                if(state == 1) { // si la pédale est on
                   state=0; // on la fait passer off
                } 
                if(state == 0) { // si la pédale est off
                   state=1; // on la fait passer on
                }
             }
          } 
       }

    __delay_ms(10);

    Et voilà pour le debounce. On rajoute 10 ms à la fin le temps que les instructions s'effectuent. Vous croyez que c'est bon ? Que nenni !

    Si on laisse le code en l'état, et qu'on maintient le pied appuyé sur la pédale, l'état va changer on / off extrêmement rapidement... Bien relou ! Il faut donc ajouter une condition, et dire de changer l'état qu'une fois que le switch a été lâché ! On rajoute donc une boucle if, après avoir attendu 200 ms (le temps d'enlever son pied ;)  )

    void main(void) {
       while(1) {
          if(GP1 == 0) { // si le switch est pressé
             __delay_ms(15); // debounce
             if(GP1 == 0) {
                __delay_ms(200); // switch relaché
                if(GP1 == 1) { 
                   if(state == 1) { // si la pédale est on
                      state=0; // on la fait passer off
                   } 
                   if(state == 0) { // si la pédale est off
                      state=1; // on la fait passer on
                   }
                }
             }
          } 
       }
    }
    __delay_ms(10);


    On peut jouer sur la durée en ms, perso j'ai trouvé que 200 était un bon intermédiaire : pas trop long (l'effet se déclenche bien quand on enlève son pied et pas 10 ans après), et pas trop court (pas de faux positifs si on appuie mal)

    Il faut maintenant préciser quoi faire quand la pédale est on ou off. Je vous rassure, c'est plus simple. On va utiliser une boucle if : elle vérifie quel est l'état de la pédale (on ou off), et ajuste les sorties en fonction (on active le relay ou non, on allume la LED ou non) :

    if(state == 1) { // si la pédale est on
       GP5=1; // on active le relai
       GP4=0;
       GP0=1; // on allume la LED 
    } 
    else { // sinon (si la pédale est off)
       GP5=0; // on inactive le relai
       GP4=0;
       GP0=0; // on éteint la LED 
    } 
    __delay_ms(10); // on attends le temps que les changements s'effectuent 

    A la fin, on ajoute un delay de 10 ms le temps que le PIC change l'état des GPIO. Je vous rassure, c'est extrêmement court et imperceptible. Si on le mettait pas, le PIC pourrait ne pas avoir le temps de changer l'état de ses pattes : il calcule plus vite qu'il ne change les voltages !

    Il faut mettre ces instructions dans la boucle while bien sûr. Et voilà !
    Donc le programme va vérifier si le switch est poussé, puis va changer (ou pas) l'état d'activation de la pédale ensuite.

    Si on écrit le programme en entier, on a :

    #include <stdio.h>
    #include <stdlib.h>

    // Librairies supplémentaires nécessaires
    #include <stdint.h>
    #include <xc.h>
    // Inclut la configuration
    #include "header.h" 

    void main(void) {
       ANSEL = 0; // pas de port analogiques
       CMCON = 0x07; // comparateur off
       ADCON0 = 0; // convertisseur ADC et DAC off

       uint8_t state; // variable qui définit l'état de la pédale
       state=0; 
       TRISIO0 = 0; // la patte 7 est une sortie (0 comme "Output")    
       TRISIO4 = 0;
       TRISIO5 = 0;
       TRISIO1 = 1; // la patte 6 est une entrée (1 comme "Input") 
       GPIO=0; // on met tous les GPIO en état bas (0V) au démarrage
       while(1) {
          if(GP1 == 0) { // si le switch est pressé
             __delay_ms(15); // debounce
             if(GP1 == 0) {
                __delay_ms(200); // switch relaché
                if(GP1 == 1) { 
                   if(state == 1) { // si la pédale est on
                      state=0; // on la fait passer off
                   } 
                   if(state == 0) { // si la pédale est off
                      state=1; // on la fait passer on
                   }
                }
             }
          } 
          __delay_ms(10);
          if(state == 1) { // si la pédale est on 
            GP5=1; // on active le relay 
            GP4=0; 
            GP0=1; // on allume la LED 
          }  
          else { // sinon (si la pédale est off) 
             GP5=0; // on inactive le relay 
             GP4=0; 
             GP0=0; // on éteint la LED   
          }
          __delay_ms(10); // on attends le temps que les changements s'effectuent
       }
    }
      Ca commence à faire un bon petit programme mine de rien, surtout pour quelquechose qui paraissait aussi simple !

      On va maintenant le transférer sur le PIC. Pour cela, il faut faire "Build" (symbole de marteau) :
      Build project
      Si tout se passe bien, il devrait vous afficher "Build successful" en bas à droite :
      Build successful
      Si ça ne marche pas, il vous dit où se situe l'erreur. Vérifiez avec le code exemple que vous n'avez rien oublié.

      Ensuite, on ouvre PicKit2. Il faut que le PIC 12F675 soit détecté. On peut alors charger le programme en ".hex" (= hexadécimal) en cliquant sur "File", et mettre "Import Hex". Le fichier compilé (en "hex" comme "hexadécimal") se trouve dans le dossier MPLABXProjects, puis Relay Bypass X, puis "dist", "default", puis "production":
      MPLAb Data import
      Il devrait le loader :


      Hex File imported
      Changez alors le VDD pour 5V, puis cliquez alors sur "Write" et il devrait être copié dans le PIC !
      Programming Successful

      Le PIC est chargé, il a alors le programme !

      Je vous conseille de vérifier sur breadboard que tout va bien :
      Et on va pouvoir assembler le circuit sur PCB !

      A noter que j'ai ajouté une option pour pouvoir rendre l'activation temporaire ou permanente, avec un deuxième switch qui va définir si on est en mode "hold" ou "temporaire". J'ai utilisé la patte 5 (GPIO.2) du PIC pour sentir l'état de ce switch, en utilisant le même système qu'avec le switch principal.

      J'ai ajouté une deuxième variable qui va dire en quel mode on est, qui s'appelle "temporary". On détecte l'état du deuxième switch pour définir cette valeur, puis en fonction de la valeur, on change le mode d'activation. Je vous laisse réfléchir un peu là dessus, je posterai le code un de ces 4 ;).

      Voilà ! Comme vous pouvez le voir, ça représente énormément de boulot de développement. Ce n'est pas si compliqué (surtout si vous êtes déjà un peu familier avec le code comme moi), mais la mise en place est difficile.

      Les PIC peuvent s'utiliser pour plein de choses différentes. Ils peuvent par exemple contrôler des potentiomètres digitaux, ce qui permet de remplacer les potentiomètres classiques, et d'avoir des presets ou des tap tempos... Plein de possibilités en somme ! Une fois qu'on a passé cette première étape, on peut imaginer pleins de projets incorporant des PIC.

      Bienvenue dans le monde du numérique ! :)


      Si vous avez des questions ou un commentaire à faire, n'hésitez pas à poster un commentaire en bas, j'essayerai d'y répondre rapidement !
      Si cet article vous a été utile, remerciez moi en likant la page facebook Coda Effects !


      Pour aller plus loin (français / anglais)
      Explications sur l'intérêt du relay bypass chez Ramble FX (en anglais)
      Sur les comparateurs : article sur sonélec musique, plutôt bien fait, et en français
      Datasheet du PIC12F675 (pdf de 132 pages, en anglais, bon courage haha)
      Tutoriel en anglais pour démarer avec le PIC12F675, bien fait (pour faire clignoter une LED)
      Tutoriel vidéo sur les GPIO, en anglais mais bien fichu pour les débutants
      Introduction vidéo en anglais sur les PIC et leur fonctionnement
      Autre article sur le relay bypass chez THCustom
       
      Previous
      Next Post »
      4 Commentaires
      avatar

      Intéressant!!

      Pour ma part, je viens d'en faire un avec une "bascule" faite avec 2 BC550 et 1 BC560, récup' sur TagBoardEffects!
      Mais le PIC prendra moins de place, c'est certain, 40x30mm sur Vero pour la bascule, relais compris!

      Répondre
      avatar

      Hello
      Quand tu lances la prod en serie avise nous !!!!!!
      J'en prendrais au moins une dizaine !!!!!! (Virer tout les 3pdt de mes pedales diy ) ������

      Répondre
      avatar

      Hello ! Pour l'instant j'ai des soucis de bruits avec les pédales high gain (normal, le relay switche plus vite qu'un 3PDT, et cause donc des "pop" plus facilement), je suis donc en train de faire une v2 avec un système qui permet d'éliminer les pops :) Quand elle sera au point, je vendrais ce système (en cours)

      Répondre
      avatar

      Salut,

      Alors? Où en es-tu?
      Commercialisable ou pas?

      Répondre