Les lumières d’ambiance et de salon ont longtemps évoluées. A l’heure où les ampoules à LED moins énergivores, font partie du quotidien, parler de lampe halogène peut s’avérer d’une autre époque.

Il y a quelques jours, mon variateur de lumière pour lampe halogène de salon s’est cassé, oui, c’est vrai  vu les épreuves auxquelles il a survécu plus de 25 ans ! Non seulement la structure mécanique de la lampe est vraiment intacte, mais aussi elle bien solide, de plus elle  garde toujours et encore une belle allurre.

D'où cet engagement à redonner une autre vie à cette lampe, en réalisant un autre variateur de lumière pour elle.

On va parle ici de :

• • • • • l’existant ;
        • les choix techniques ;
        • les différentes étapes pour la réalisation du variateur ;    
        • puis on finira par une mise en œuvre de la lampe et son variateur.

Si vous tombez à tout hazard sur cet article, et que vous souhaitez réaliser ce montage, sachez qu'il met en oeuvre des tensions électriques dangeureuses peuvant entraîner la mort. Même une simple électrisation peut aussi avoir des conséquences sur votre santé. Evitez les court-circuits! Revérifiez bien votre montage. Si vous n'êtes pas sûr de ce que vous faites, surtout n'allez pas à l'aventure. Si vous y tenez quand même, faites vous aider par une personne compétente. La vérification du montage devra toujours se faire avec prise d'alimentation 220Volts débranchée.

L’existant:

Le variateur de lumière actuel repose sur une structure simple bâtie autour d’un triac (BTA16), un diac, une diode zéner, deux condensateurs, un potentiomètre à glissière, résistance et une inductance.

Des schémas électriques de variateurs existent sur la toile; par exemple l’excellent site  sonelec-musique  parcourt de façon conséquente les schémas de variateurs, les différentes variantes de ces schémas, les composants utilisés, leur rôle…

Choix techniques:

Pour ma part n’ayant pas sous la main une inductance,  ne sachant pas comment en fabriquer, n’ayant pas non plus les moyens de vérifier sa valeur, dans l’immédiat, pris dans l’urgence, le choix s’est aussitôt porté sur une solution à microcontrôleur.

Là encore sur le site arduino cc, on trouve aussi des solutions de variateurs de lumière pilotés par le module Arduino Uno.  On peut même en trouver un peu partout dans la toile.

En fouillant dans mes boîtes à composants, j’ai retrouvé au fond du tiroir, quelques microcontrôleurs PIC16F88, du fabricant Microchip, autant mieux en utiliser un d’entre eux, même s’il sera surdimensionné pour son utilisation. Je n’ai pas envie que ces précieux composants finissent à la poubelle sans être utilisés, par les temps qui courent où le silicium devient rare.

Le microcontrôleur PIC16F88, servira donc à gérer le variateur à réaliser.

Pour faire varier la lumière, on a le choix entre deux techniques : la modulation de largeur d’impulsions ou la détection du passage par zéro du signal sinusoïdal du secteur.

Technique n°1 :

La modulation de largeur d’impulsions (PWM), fait varier le rapport cyclique d’un signal carré, de fréquence fixe,  en agissant sur la durée pendant laquelle le signal restera à l’état haut.

Plus cette durée est grande, plus la puissance disponible pour la lampe le sera aussi, et la lumière sera intense.

Plus cette durée est petite, plus la puissance disponible pour la lampe sera faible, et la lumière sera moins intense.

Le composant qui enverra la puissance à la lampe sera, soit un triac ou un transistor de puissance.

Technique n°2 :

Le triac est utilisé comme dispositif de commande.

Avant de poursuivre, un triac est un interrupteur qui laisse passer le courant lorsqu’on lui applique une commande sur sa gâchette. Mais sa particularité c’est qu’il cessera de conduire lorsque le courant direct (le courant qui circule entre l’anode A2 ou MT2, et l’anode A1 ou MT1)  disparaîtra.

On va donc détecter lorsque le signal sinusoïdal du secteur passe par zéro :

A chaque passage par zéro, matérialisé par un cercle rouge sur la figure précédente, une impulsion sera envoyée sur la gâchette du triac afin de l’amorcer.

On peut ainsi retarder l’envoi de cette impulsion après chaque détection du passage par zéro.  Plus ce retard est grand, plus la tension efficace disponible sur la lampe diminue, et donc sa luminosité.

Par exemple dans le cas de figure ci-dessous,  lorsque le retard  petit, on a:

Et ici pour un retard plus grand, on obtiendra :

Comme on peut le voir sur la figure précédente, de la sinusoïde de départ, il ne restera plus grand chose; d’où une faible luminosité.

On pourra donc augmenter ce retard jusqu’à ce que le signal disparaisse complètement, entraînant ainsi une valeur efficace nulle ; donc l’extinction de la lampe.

Etapes de réalisation:

Pour réaliser notre variateur de lumière, on va utiliser la technique n°2 : la détection de passage par zéro du secteur.

Etape 1: Le schéma électrique

Au lieu de relier directement la broche 4 du microcontrôleur (RAS/MCLR) au +5V comme dans le schéma, on intercaler une résistance de 10KOhms entre le +5V et la broche RAS/MCLR. C'est ce qui a été finalement rajoutée sur la platine d'essai.

Ce montage est divisé en quatre grands sous-ensembles :

La détection 

Ce sous-ensemble permet de détecter chaque passage à zéro de la tension secteur. Le pont de diodes moulé (on peut très bien utiliser 4 diodes 1N4007 à la place), permet de redresser la tension secteur en double alternance. Dès que cette tension descend en dessous du seuil d’éclairement de la LED de l’opto coupleur 4N35, celle-ci s’éteint ; elle se rallumera lorsque que cette tension passe au dessus de ce seuil. Les résistances R1 et R2 protègent la LED de l'opto coupleur.

Chaque passage à zéro du secteur produira donc des impulsions négatives, aux bornes de la résistance R3. 

La fréquence du secteur étant de 50Hz, soit une période de 20ms, ces impulsions apparaîtront toutes les 10ms.

La commande 

Les impulsions générées sont envoyées la broche 6 du microcontrôleur, qui se charge de calculer en conséquence le retard qu’il faudra pour envoyer l’impulsion de commande de la gâchette du triac. Cette commande de gâchette est faite par la broche 9 (RB3) du microcontrôleur.

Ce retard sera plus ou moins grand selon le nombre de fois ou selon la durée d’appuis sur le bouton poussoir.  Un appui sur le bouton poussoir correspond à un état haut.

En limite basse, chaque appui sur le bouton poussoir augmentera le retard; lorsque la limite haute est atteinte, chaque appui se manifestera par une diminution du retard.

Le microcontrôleur fonctionnera avec son horloge interne.

Pour ce qui est du bouton poussoir on a choisi un modèle de bouton à pied, à maintien qu'on a modifié pour supprimer la fonction maintien.

La puissance

Les impulsions envoyées sur l’optotriac MOC3021, vont ainsi déclencher le passage du courant à travers le triac, et la lampe pourra ainsi s’allumer. En effet la luminosité dépendra du moment auquel l’impulsion est envoyée. Un réseau RC monté aux bornes du triac permet de le protéger, et de supprimer des parasites générés par celui-ci pendant ses phases de commutation.

L’alimentation +5V

C’est elle qui va alimenter la partie commande. On n’a pas souhaité concevoir une alimentation directe sur le secteur, pour éviter de mettre la platine toute entière à la merci du 220V. Pour cette raison, le +5V est fourni par le chargeur d’un ancien téléphone Samsung S5, qu’on a mis à contribution pour faire la platine d’essais:

Celui-ci peut délivrer un courant de 700mA, c’est plus que suffisant.  Des petits convertisseurs 220V/5V de taille très réduite existent aussi dans le commerce, on peut aussi bien les utiliser. Ou alors une alimentation avec un transformateur 220V/12V muni d’un régulateur 5V et des condensateurs de filtrage,  fonctionnera tout autant.

Etape 2: Réalisation du montage d’essai

Liste des composants utilisés :

• • Résistances : 2 x 47KOhms 1/4W, 2 x 1KOhms 1/4w, 2 x 10KOhms 1/4W, 330Ohms 1/4W, 100Ohm/1W.
  • Condensateurs : 100nF 400V
  • Opto coupleur : 4N35 ou 4N32
  • Opto triac : MOC3021
  • Diodes : 4x1N4007 ou un pont de diodes intégré 1A
  • Triac : BTA16-600BW
  • Fusible : 250V/2A
  • L’alimentation +5V : alimentation de chargeur d’un vieux téléphone Samsung.
  • Bouton poussoir, du type interrupteur à pied
  • Boitier plastique de 115 x 62 x 36 environ.
  • Borniers pour fils à souder : 2 x 3 contacts, 1 x 2 contacts

On a utilisé une plaque à trous pastillés pour souder les composants dessus, ainsi que les supports des circuits intégrés : microcontrôleur, opto coupleur et opto triac :

Plaque avec composants montés :

Pour l'alimentation du Samsung S5, le +5V et 0V de l'alimentation, sont respectivement les fils blanc et bleu. En vue de dessous les connexions essentielles du module:

Voici une idée des soudures effectuées, côté pastilles:

On a aussi rajouté un radiateur au triac.

Etape 3 : Programmation du microcontrôleur

Le programme du microcontrôleur consiste à détecter les passages par zéro de la tension du secteur, puis d'envoyer sur la gâchette du triac, des impulsions de 10µs dont le retard dépend des appuis sur le bouton poussoir.

Pour détecter les passages par zéro, on va utiliser l'entrée d'interruption externe à savoir la broche RB0 du microcontrôleur. Ainsi à chaque front montant sur cette broche, un programme d'interruption sera exécuté.

Ce programme d'interruption se résume simplement à envoyer l'impulsion de 10µs sur la sortie RB3. A chaque appui sur le bouton poussoir connecté sur l'entrée RB4, une variable de comptage est incrémentée jusqu'à une limite haute, puis sera décrémentée jusqu'à la limite basse. C'est le contenu de cette variable qui servira de valeur de retard pour l'impulsion d'amorçage.

A chaque incrément ou décrément de la variable correspondra une durée de 78µs du moins en théorie car on compte en tout 128 incréments, de 0 à 127 ou de 127 à 0.

Ce choix est justifié par le fait qu'on a une durée de 10ms entre deux passages à zéro. Soit 10000µs, pour parcourir cette durée en 128 pas, chaque pas aura une durée de 78µs.

C'est ce que fait la routine ci-dessous:

       do{
               __delay_us(35);
           }while(--dim_val);
                 bulb = 1;
                 __delay_us(10);
                 bulb = 0;  

"dim_val" c'est le contenu du compteur du nombre d'appuis sur le bouton poussoir.

Comme on peut le constater cela ne correspond pas exactement aux valeurs théoriques précédentes, on devrai avoir dans la fonction __delay_us() la valeur 75 au lieu de 35. En effet les boucles écrites en C, se traduisent par des entêtes supplémentaires au moment de la compilation, ce qui a pour effet de rajouter des cycles machines en plus.

Une solution possible pour se rapprocher au maximum de 78µs, serai d'écrire cette routine en assembleur; ce qui n'a pas été fait ici. C'est en modifiant la durée d'un pas pour la ramener à valeur bien supérieure à 35µs; qu'on a pu touver à force des essais des sauts plutôt acceptables.

Ci-dessous tous les fichiers du programme, réalisés grâce à l'environnement de programmation MPLAB X

Ici on a le fichier d'entête des broches du composant:

     
   /* 
    * File:  deviceio header 
    * Author: JtBB
    * Comments:
    * Revision history: 1.0
    */

    // This is a guard condition so that contents of this file are not included
    // more than once.  
    #ifndef __DEVICEIO_H
    #define	__DEVICEIO_H
  
    // TODO Insert appropriate #include <>
    #define zero_cross_detect RB0 //zero cross input port B 0
    #define bulb RB3 //Lamp on port B pin 3 (3))
    #define pushButton RB4 //push button on port B pin 0 (1))
    #define zero_cross_detect_dir TRISB0
    #define bulb_dir TRISB3
    #define pushButton_dir TRISB4
    #define In 1   //port as input
    #define Out 0  //port as output
    #define KEY_NONE 0 //no button hit
    // TODO Insert C++ class definitions if appropriate

    // TODO Insert declarations

    // TODO Insert declarations or function prototypes (right here) to leverage 
    // live documentation


    // TODO If C++ is being used, regular C code needs function names to have C 
    // linkage so the functions can be used by the c code. 

    #endif	

Cet autre fichier d'entête, comprend toutes les entêtes y compris celle du compilateur, les fusibles du composant, ainis que les prototypes des fonctions:

  
   /* 
    * File:  includes header 
    * Author: JtBB
    * Comments:
    * Revision history: 1.0
    */

   // This is a guard condition so that contents of this file are not included
   // more than once.  
   #ifndef __INCLUDES_H
   #define	__INCLUDES_H
   // Device configuration bit
   // CONFIG1
   #pragma config FOSC = INTOSCIO       // Oscillator Selection bits (HS oscillator); 
   #pragma config WDTE = OFF       // Watchdog Timer Enable bit (WDT disabled)
   #pragma config PWRTE = OFF      // Power-up Timer Enable bit (PWRT disabled)
   #pragma config MCLRE = ON      // RA5/MCLR/VPP Pin Function Select bit (RA5/MCLR/VPP pin function is digital I/O, MCLR   internally tied to VDD)
   #pragma config BOREN = ON       // Brown-out Reset Enable bit (BOR enabled)
   #pragma config LVP = OFF        // Low-Voltage Programming Enable bit (RB3 is digital I/O, HV on MCLR must be used for programming)
   #pragma config CPD = OFF        // Data EE Memory Code Protection bit (Code protection off)
   #pragma config WRT = OFF        // Flash Program Memory Write Enable bits (Write protection off)
   #pragma config CCPMX = RB3      // CCP1 Pin Selection bit (CCP1 function on RB0)
   #pragma config CP = OFF         // Flash Program Memory Code Protection bit (Code protection off)

// CONFIG2
   #pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
   #pragma config IESO = OFF       // Internal External Switchover bit (Internal External Switchover mode disabled)

   // #pragma config statements should precede project file includes.
   // Use project enums instead of #define for ON and OFF.
   #include  // include processor files - each processor file is guarded.
   // TODO Insert appropriate #include <>
   #include "deviceio.h"
   // TODO Insert declarations
   #define _XTAL_FREQ  8000000  //internal oscillator 8 MHz 

   // TODO Insert declarations or function prototypes (right here) to leverage 
   // live documentation
   void init_ports_and_registers(void);
   void enable_interrupts(void);
   unsigned int dim_value_to_send(void);
   void check_dim_val_and_update_it(void);
   // 
   // TODO If C++ is being used, regular C code needs function names to have C 
   // linkage so the functions can be used by the c code. 

   #endif	

On a ici le programme principal

/*
 * File:   bulb_triac_main.c
 * Author: JtBB
 *
 * Created on 02 juillet 2022, 12:13
 * release: 
 */

#include "includes.h"
//variables
unsigned char zc_event = 0; 
unsigned char dim_val = 0;
unsigned char counter_dir = 1;
unsigned int counter = 2;


//function init_port_and_registers(), initialise port and registers
void init_ports_and_registers(void){
    OSCCONbits.IRCF = 0b111;
    bulb = 0;
    bulb_dir = Out; //
    pushButton = 0;
    pushButton_dir = In; //push button is an input
    zero_cross_detect = 0; //input pin RB0 for zero cross detect
    zero_cross_detect_dir = In; //as input
}

//interrupt service routine for portB pin RB0 rising edge
void __interrupt() bulb_isr(void){
    
       zc_event = 1; //zero cross event occured
       INT0IF = 0;
    
}
//function enable interrupts
void enable_interrupts(void){
    INTCONbits.GIE = 1; //enable all interrupts
    INTCONbits.PEIE = 1;
    INTCONbits.INT0IE = 1; //enable INT0 interrupt
    OPTION_REGbits.INTEDG = 1; //on rising edge 1
}
//function check_dim_val_and_update_it(), adjust upper and lower end limit for
//dimming value
void check_dim_val_and_update_it(void){
    if(counter > 240){
        counter_dir = -1;
        counter = 240;
    }
    if(counter <= 2){
        counter_dir = 1;
        counter = 2;
    }
}
//function dim_value_to_send()
unsigned int dim_value_to_send(void){

    if(pushButton){
        if(counter_dir == 1){
            counter++;
        }
        else{
            counter--;
        }
    }
   return counter; //value to wait before sending pulse
}
//main 
void main(void) {
    init_ports_and_registers();
    enable_interrupts();
    // 
    while(1){
        //
       if(zc_event){
           zc_event = 0; //clear this and wait for another event
           //
           check_dim_val_and_update_it();
           //
           dim_val = dim_value_to_send();
           //
           //wait brefore firing the triac    
           do{
               __delay_us(35);
           }while(--dim_val);
                 bulb = 1;
                 __delay_us(10);
                 bulb = 0;        
       }
    }
    
}

Mise en oeuvre:

Cette vidéo n'a pas de son, activez le sous-titrage, merci.

Conclusion:

La maquette réalisée a montré que le variateur jour bien son rôle pour notre lampe halogène. le type de boîtier choisi offre un encombrement réduit. A présent, il reste à réaliser le ciruit imprimé.

Toutes fois quelques règles sont à respecter:

Le dimensionnement des composants, et la taille des pistes du circuit imprimé. Pour le circuit de puissance (220V), les pistes doivent être le plus court possible et le plus large possible. Il ne faut pas hésiter à faire des pistes dont la largeur dépasse les 10mm. Le circuit devra être contenu dans un boitier palstique, pour éviter tout risque avec le courant électrique.