Ambiance Lumineuse & Simulation de Télé

En 3 versions:

1. Commande par boutons !
2. Commande par télécommande
3. Commande par Bluetooth de Smartphone Androïd

Ce que je propose ici, c'est un équipement pour créer une ambiance lumineuse avec un ruban de leds, à 3 couleurs (Rouge Vert Bleue), adhésif pour le poser à votre guise en éclairage indirecte ! Chaque couleur étant individuellement réglable, vous disposez d'une palette de teintes infinies et d'une intensité lumineuse réglable à souhait .

Une deuxième fonction, non négligeable, est que le dispositif, à sa mise sous tension, génère un mode aléatoire en teintes et en temps, qui simule en votre absence, le fonctionnement de la télé sur les murs, rideaux, volets, etc...

Pour passer du mode "fonctionnement aléatoire" en mode gradateur trois couleurs, on appuie sur la touche 'OK', puis on peut doser chaque couleur, en commençant par le bleu, puis le vert, et le rouge, en utilisant les touche 'Up' et 'Dw', avec un appui sur 'Ok' après chaque réglage, et ainsi de suite. Le retour au mode aléatoire, se fait en appuyant simultanément sur les deux touches 'Up' & 'Dw' , ou en coupant le courant (Power On Reset).

La réalisation se décline sous la forme d'une trilogie. Le model présenté ici est la version Commande par boutons ! Plus bas, il y a une version commandée par Télécommande Infrarouge et une version réglée par Smartphone BlueTooth Androïd ou tablette.

Le ruban de leds de cinq mètres vaut $3 chez http://aliexpress.com et le module Arduino Nano, $2 chez le même fournisseur...  

Le Schéma :

Commençons par faire le tour de la propriété ! Le coeur du montage est un Arduino Nano, qui, en plus d'être bon marché, compacte, et pré-câblé, offre des sorties PWM (Modulation de largeur d'impulsions) en grand nombre. C'est ces dernières que nous allons utiliser pour varier chaque couleur. Vous l'aurez compris, on ne travaille pas sur la tension d'alimentation de leds mais sur le temps d'éclairement de celles-ci en dépassant largement la persistance rétinienne pour éviter tout phénomène de papillotement ou de scintillement . L'énergie étant fournie par un bloc secteur 12 volts, on nettoie l'arrivée par C1; les autres tensions sont fabriquées par l'Arduino.

On dispose de 3 boutons poussoir (Montée, descente de l'éclairage et Ok validation) sur 3 entrées digitales, tirées à "0" par des résistances de pull-down sur chacune; les valeurs ne sont pas critiques. Arduino permet de déclarer des résistances de pull-up internes, mais il faut inverser le niveau actif des entrées et mon circuit était déjà tracé .

Les sorties PWM viennent attaquer un opto-coupleur 4N35 via la résistance de limitation 470R afin d'assurer la séparation galvanique du 5 volts et de la puissance en 12 volts.

Les opto-couleurs pilotent des transistors Mos-Fet (IRLZ44N) via des résistances de limitation, des résistances de mise au potentiel bas, et des leds qui, en plus de servir de témoin de visualisation, abaissent l'impédence d'entrée et absorbent au pire des cas les courants inverses présentés sur le gate du transistor, tout en réduisant l'effet capacitif gate/source ! J'ai choisi volontairement un Mos-Fet pour leur basse résistance Drain/Source (RDSon) afin de bénéficier d'un plein rendement et d'un échauffement quasi nul ...

Le circuit imprimé :

L'implantation des composants:

Les CMS sont montés côté soudure et les composants traversants, de l'autre côté .

Le programme :

Pas de remarque concernant le programme; Le tout a été développé avec le logiciel Arduino en freeware et j'ai volontairement enrichi les commentaires pour éviter un descriptif hors page .

/* Programme de simulation de télé en fonctionnement en absence,
 *  et de commande de leds multicolores pour ambiance lumineuse.
 *  Par B.LECLERC/FEELGOOD
 */

const int UpButton = 7;   // Déclaration d' Entrees
const int DwButton = 8;
const int OkButton = 12;

int ledRed = 3;   // Déclaration de Sorties
int ledGrn = 5;
int ledBlu = 6; 

int val0 = 0;         // variables à valeurs aléatoires
int val1 = 0; 
int val2 = 0;
int tmp;
int Nbr = 0;
int Rng = 0; 

void setup()

{ 
  pinMode(ledRed, OUTPUT);   // Direction des pinuches
  pinMode(ledGrn, OUTPUT);
  pinMode(ledBlu, OUTPUT); 
  pinMode(UpButton, INPUT);
  pinMode(DwButton, INPUT);
  pinMode(OkButton, INPUT);
  
}

void loop(){
Debut:  // Sous programme de mise sous tention--> simulation télé en marche !
val1 = random (0,255); // Genération de valeurs aléatoires calibrées pour simulation télé !
val2 = random (0,255);
val0 = random (0,255);
tmp = random (300,3000);

if (digitalRead(OkButton)==HIGH){  // Contrôle de la demande d'accès au réglage manuel de luminosité !
  val1 = 0;  // R à Z des couleurs si demande d'accès aux réglages manuels de luminosité !
  val2 = 0;
  val0 = 0;
  goto usage; // Saute au sous programme du réglage manuel de luminosité !
  }

analogWrite(ledRed, val1);  // Ecriture des valeurs aléatoires sur les sorties leds, pendant un certain temps !
analogWrite(ledGrn, val2);
analogWrite(ledBlu, val0);
delay (tmp);
goto Debut;  // Retour au debut et ainsi de suite !

usage:  // Label de sous programme de demande de réglage manuel !

if (digitalRead(OkButton)==HIGH){  // Choix de la couleur à régler !
  Rng = Rng + 1;
  if (Rng == 4)(Rng = 1); // Remise à la 1° couleur!
  delay (500);
} 
if (digitalRead(UpButton)==HIGH){  // Monte de 0 à 255 par pas de 10 !
  Nbr = Nbr + 10;
  if (Nbr > 255)(Nbr = 0);  // Trop Grand --> RàZ !
  delay (200);
}
if (digitalRead(DwButton)==HIGH){   // Descend de 255 à 0 par pas de 10
  Nbr = Nbr - 10;
  if (Nbr < 1)(Nbr = 0);  // Trop Petit --> Valeur maxi !
  delay (200);
}

  if (Rng == 3){  // Attribution de la valeur à la couleur !
    (val1 = Nbr);
  }
  if (Rng == 1){ // Attribution de la valeur à la couleur !
    (val2 = Nbr);
  }
  if (Rng == 2){ // Attribution de la valeur à la couleur !
    (val0 = Nbr);
  }

analogWrite(ledRed, val0);  // Ecriture des valeurs réglées sur les sorties leds !
analogWrite(ledGrn, val2);
analogWrite(ledBlu, val1);

  if (digitalRead(UpButton) == HIGH  && digitalRead(DwButton) == HIGH) {  // Remise en mode aléatoire en appuyant sur plus et moins simultanément !
    goto Debut;
  }

goto usage; // Et retour au sous-programme de réglage manuel !
} 

Les premiers tests:

Les fichiers Originaux sont Zipés ici :

Cde led (71.29 Ko)

Nous avons tous une multitude de télécommandes pour commander nos appareils ! Bien souvent, ces boîtiers ne sont utilisés que pour quelques fonctions. Donc plutôt que multiplier les zapettes, on va pouvoir servir les fonctions inutilisées pour commander l'éclairage à leds, cité plus haut . Personnellement, j'ai utilisé les touches 4,5,6,7,8,9,0 * et # qui ne servaient pas sur le boîtier de ma chaîne Hi-Fi (Voir ici !) . J'ai donc capturé les codes générés par ces boutons et les ai affectés à la commande de mon ruban de leds ! Vous pouvez visualiser les codes de vos zapettes avec le logiciel joint dans l'article relatif !

Le schéma :

Très peu de différences, par rapport au précédent ! La partie puissance reste identique, seul, les 3 boutons sont remplacés par un récepteur infra-rouge type Keyes :

On peut utiliser également un récepteur IR de type WS1838B mais il ne faudra pas oublier de modifier le brochage, de l'alimenter derrière une résistance de 68 ohms filtré par un 10µF!

Le circuit imprimé:

L'implantation des composants:

Le programme:

Le programme ici ne rempli que la fonction gradateur pour leds, le simulateur n'est pas inclus ; ce sera un bon exercice pratique pour qui voudra s'y coller !

#include <IRremote.h>

int broche_reception_ir = 2; // broche 2 utilisée en entrée IR
int ledRge = 9;
int ledVrt = 5;
int ledBlu = 6; 

IRrecv reception_ir(broche_reception_ir); // crée une instance de réception
decode_results decode_ir; // stockage données reçues

int val3 = random (0,255);         // variables
int val1 = random (0,255); 
int val2 = random (0,255); 

void setup()

{ 
  pinMode(3, OUTPUT);   // sets the pin as output
  pinMode(5, OUTPUT);   // sets the pin as output
  pinMode(6, OUTPUT);   // sets the pin as output
  pinMode(2, INPUT);
  
  reception_ir.enableIRIn(); // démarre la réception 

}

void loop(){

  if (reception_ir.decode(&decode_ir)) 
  { 
    if (decode_ir.value == 0xFF7A85) 
    { 
      // touche 6 -> monte led bleues
    val3= val3 + 25;
      analogWrite(ledBlu, val1);
    } 

     
    if (decode_ir.value == 0xFF5AA5) 
    { 
      // touche 9 -> Baisse led bleues
    val3= val3 - 25;
      analogWrite(ledBlu, val3);
    } 
                                     

     if (decode_ir.value == 0xFF18E7) 
    { 
      // touche 5 -> monte led vertes
    val2= val2 + 25;
      analogWrite(ledVrt, val2);
    } 

       if (decode_ir.value == 0xFF38C7) 
    { 
      // touche 8 -> Baisse led vertes
    val2= val2 - 25;
      analogWrite(ledVrt, val2);
    } 

       if (decode_ir.value == 0xFF30CF) 
    { 
      // touche 4 -> monte led rouges
    val1= val1 + 25;
      analogWrite(ledRge, val1);
    } 

       if (decode_ir.value == 0xFF10EF) 
    { 
      // touche 7 -> Baisse led rouges
    val1= val1 - 25;
      analogWrite(ledRge, val1);
    } 

      if (decode_ir.value == 0xFF4AB5) 
    { 
      // touche 0 -> Eteind tout
    val1= 0;
    val2= 0;
    val3= 0;
      analogWrite(ledRge, val1);
            analogWrite(ledVrt, val2);
                  analogWrite(ledBlu, val3);
    }

    if (decode_ir.value == 0xFF42BD) 
    { 
      // touche * -> Eteind tout avec mémoristion

      analogWrite(ledRge, 0);
            analogWrite(ledVrt, 0);
                  analogWrite(ledBlu, 0);
    }

             if (decode_ir.value == 0xFF52AD) 
    { 
      // touche # -> Alume suivant mémorisation
      analogWrite(ledRge, val1);
            analogWrite(ledVrt, val2);
                  analogWrite(ledBlu, val3);
    }
    reception_ir.resume(); // reçoit le prochain code 
  }   
} 
  

N'oubliez pas d'éditer les codes de la télécommande utilisée et de les remplacer dans le programme si vous voulez que votre télécommande soit reconnue .

Les fichiers pour la réalisation:

Cde led (71.29 Ko)

Comme mon but n'est pas de réinventer le fil à couper le beurre, et que je ne me suis pas encore frotté au développement pour Androïd, je me suis permis d'utiliser une application existante et de lui asservir mon montage, en ajustant le soft au cahier des charges requis. Seules les trois potentiomètres du bas servent dans mon application; Après avoir activé le bluetooth, et appairé (juste la 1°fois ) le module avec le Smartphone ou la tablette androïd, il faut aller dans les paramètres (en bas à gauche, en principe) et "connecter" SPP-CA ! la led va s'allumer sur le circuit imprimé pour exprimer la communication des deux éléments. Il ne reste qu'à agir sur les trois premiers potentiomètres pour créer l'ambiance souhaitée en panachant les couleurs .

Le Schéma:

Le schéma de base reste le même; je n'ai fait que remplacer les boutons ou le récepteur infrarouge par un tranceiver bluetooth de type SPP-CA disponible à $1,50 chez Aliexpress .Il suffit de raccorder les entrées/sorties TX et RX de l'Arduino en les croisant sur le module Bluetooth... On câblera la led bleue, limitée par une 470 ohm, sur la borne 25 du récepteur; cette led nous indiquera la connexion du SPP-CA avec le terminal androïd . L'alimentation du module est assurée par le 3v3 fabriqué par l'arduino, ce qui explique la présence du pont diviseur de tension R13 et R14 pour ramener le niveau TX d'arduino de 5v à 3v3 de RX du SPP-CA.

Le circuit imprimé:

On commencera par souder le circuit SPP-CA, côté sérigraphie, une attention toute particulière est à apporter au soudage de ce circuit sur le print principal, car le dos, et les pins inutilisées, ne doivent pas toucher les plans de masse et autres; j'ai surélevé le circuit par une double épaisseur de ruban adhésif que j'ai retiré après soudure.

Après cela on testera la qualité du soudage et l'isolation avec un testeur de continuité ou un ohmmètre très basse tension, afin de ne pas détruire les IO's du SPP-CA ! Le pas des points de connexion est de 1,5 mm, ce qui impose précision et un fer à souder adéquat . On procèdera ensuite au soudage des autres CMS avant de monter les staps et composants discrets .

Le programme:

Le soft est une adaptation de ce qu'a développé Mr Hazim BITAR ; car j'utilise son app. androïd sur mon Smartphone pour piloter mon circuit ... Je ne vais pas décrire les lignes de ce programme, car les commentaires situés derrière les doubles slashs "//" permettent de voir ce qui est fait par chaque ligne .

/*
 PROJECT: Smart_Cmd_Led
 PROGRAMMER: B.LECLERC
 DATE: 08/26/16
 Special Thanks: Hazim BITAR
*/

#define START_CMD_CHAR '*' // Caractere de demarrage  
#define CMD_ANALOGWRITE 11
#define MAX_ANALOGWRITE 255  //Valeur maxi transmise aux sorties analogiques

void setup() {
  Serial.begin(9600); //Initialisation de la com série 
  Serial.flush();
}

void loop()
{
  Serial.flush();
  int ard_command = 0; //Mise à zero des variables
  int pin_num = 0;
  int pin_value = 0;

  char get_char = ' ';  // Lecture du caractère sur le port serie

  // Attente d'une data
  if (Serial.available() < 1) return; // si le port serie est vide, retourne à loop().

  // Reconnaissance du caractère de début de chaîne 
  get_char = Serial.read();
  if (get_char != START_CMD_CHAR) return; // Si ce n'est pas le caratere de debut, retourne à loop().

  // Reconnaissance du type de commande
  ard_command = Serial.parseInt(); // Lit la commande
  
  // Reconnaissance de la pinuche et de la valeur  
  pin_num = Serial.parseInt(); // Lit la pinuche
  pin_value = Serial.parseInt();  // Lit la valeur 

  // Traitement des datas de ARDUDROID sur sortie analogique
  if (ard_command == CMD_ANALOGWRITE) {  
    analogWrite(  pin_num, pin_value ); 
    // ajoute la valeur sur la pinuche 
    return;  // Fait. retourne à loop();
  }

 }
 

Les fichiers originaux:

Bt cde led (36.12 Ko)

L'app Androïd utilisée: