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 ?
- Schéma du circuit
- Le microcontrôleur : le PIC12F675
- Le relai
- Interface PIC / PC
- Configuration du PIC
- Code en C pour sentir le switch
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 :
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) :
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 :
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.
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 :
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.
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 :
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) :
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 :
Normalement, si vous ouvrez PicKit2, il devrait détecter le PICkit ("PICkit 2 connected") :
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" :
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 :
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" :
- 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".
// Définir la fréquence de l'oscillateur
#define _XTAL_FREQ 4000000
#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" :
Normalement, vous devriez avoir cela maintenant dans la fenêtre principale :
// Librairies supplémentaires nécessaires
#include <stdint.h>
#include <xc.h>
// Inclut la configuration
#include "header.h"
#include <stdint.h>
#include <xc.h>
// Inclut la configuration
#include "header.h"
Vous devriez avoir cela maintenant :
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.
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;
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
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 :
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é
}
}
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 :
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);
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);
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
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
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
// Librairies supplémentaires nécessaires
#include <stdi
// 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") state=0;
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
__delay_ms(10); // on attends le temps que les changements s'effectuent
}
}
On va maintenant le transférer sur le PIC. Pour cela, il faut faire "Build" (symbole de marteau) :
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":
Le PIC est chargé, il a alors le programme !
Je vous conseille de vérifier sur breadboard que tout va bien :
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 !
10 Commentaires
Intéressant!!
RépondrePour 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!
Hello
RépondreQuand tu lances la prod en serie avise nous !!!!!!
J'en prendrais au moins une dizaine !!!!!! (Virer tout les 3pdt de mes pedales diy ) ������
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épondreSalut,
RépondreAlors? Où en es-tu?
Commercialisable ou pas?
Salut !
RépondreSuper article,chapeau. J'avais peur rien qu'à l'idée de lire un truc sur la programmation de PIC... tu m'as prouvé que j'avais tort !
Du coup, je me dis que recréer un flexi-switch d'Earthquaker (push court = changement état de la pedale, push long = changement temporaire le temps du push) ne doit pas être bien (plus) compliqué (que le taf que tu as déjà fait)!
;-)
Bonjour,merci pour l'article.J'ai réalisé un montage avec un relais 9v afin de pouvoir utiliser ma wah juste en appuyant dessus (comme la Wowee wah).J'ai fabriqué un inter positionné sur le dessus de la wah avec des micros switches montés en // sur un veroboard et .. un morceau de téléphone (Xperia quand même,c'est plus classe.).Ça marche impec sauf que j'ai un bruit à l'activation de la wah.Pas un plop mais comme si le clic du relais était amplifié.J'ai mis une résistance de 1M sur la sortie du boîtier puis sur l'entrée de la wah ,c'est pareil.On m'a conseillé de mettre un condo de 470uf en // sur le relais : c'est pareil.Ça retarde l'extinction du relais mais c'est tout.
RépondreAvez-vous une idée pour résoudre ce problème?
Le relais est un Finder 9v D26 (30.22.7.009.0010).
Merci
je joins une petite vidéo faite à l'arrache (la guitare est désaccordée et , oui,ce sont des crocs que j'ai au pied 😉🤟 )
http://clicecole.free.fr/perso/wah.mp4
Salut, je découvre ton blog suite à un pédalier switcher en cours de fab. En effet, hier j'ai tout fini d'assembler et puis connecté le tout. 8 écrans Oleds, 6 sitchs, un Arduino 2560 mini, 24 relais pour le choix des pédales... Et un bon petit buzz sans même brancher de guitare.... Alors, j'ai câblé l'audio sans câble blindé. Je pense qu'une partie de mon problème vient de là. je dois reca^bler tout l'audio avec du blindé et relier toutes les masse. J'espère ainsi réduire le bruit. Qu'en penses-tu? Je pense que l'arduino génère pas mal de parasites. Fred
Répondrehttps://ln2.sync.com/dl/f899af8a0/xh7fx53d-y9tsij5z-nqutvzy9-4n9772pt
RépondreBonjour. Solution de relai très intéressante. En termes de consommation, par rapport aux relais JFET que vous présentez dans l'analyse de la reverb, quelle est la solution la plus économe ?
RépondreBonjour. Autre petite question : j'ai l'impression que l'entrée GPIO.1 est toujours alimentée en ~+5V et que le changement d'état se fait lorsque cette tension passe à 0V (le switch relie le +5V à la masse et empêche l'arrivée de courant à la pin du PIC). C'est bien cela ?
RépondreQuelle en est la raison ? rester sur une entrée logique ? car tester les +5V nécessiterait de passer l'entrée en analogique ?
Quel impact sur la conso ? L'alimentation permanente en +5V consomme moins que l'activation du convertisseur analogique ?
Merci