Accueil > Arduino, impression 3D, Matériel > Transformation d’une lampe de bureau

Transformation d’une lampe de bureau

L’électronique (ballast) de ma lampe de bureau a rendu l’âme. Plusieurs choix me sont proposés :

  • Soit trouver un ballast de rechange.
  • Soit jeter la lampe de bureau.
  • Soit modifier la lampe pour y mettre des LEDs.

Bien sûr c’est ce dernier choix que j’ai opté. Le seul inconvénient est que l’éclairage va être moins puissant mais sera tout de même suffisant pour travailler sur un ordinateur.

Un dernier point, je ne veux rien acheter et utiliser que des composants que je possède actuellement.

Le cahier des charges sera le suivant :

  • L’affichage s’effectuera via un bandeau de LED WS2812b.
  • Ayant des Arduino Pro mini 5v 16 Mhz, je vais partir sur ce choix pour le pilotage de l’ensemble :

  • Un récepteur infrarouge récupéré sur d’anciens jouets.
  • Une télécommande infrarouge qui permettra de sélectionner l’intensité et la couleur d’affichage souhaitées.
  • Une alimentation de téléphone 220v / 5v.

Voyons comment se présente cette lampe de bureau articulée :

La lampe possède un réflecteur et un cache en plastique qui contient l’électronique :

On peut voir le ballast qui ne fonctionne plus.

La première étape est de définir l’emplacement du bandeau de LEDs et donc le nombre de LEDs nécessaires. Le bandeau de LEDs que je possède est le suivant :

C’est un bandeau qui contient 30 LEDs par mètre. Je dispose de l’espace suivant sur le réflecteur de la lampe : 170 mm x 90 mm. Donc après un calcul rapide, je peux facilement installer 4 ou 5 bandes espacées de 5 LEDs.

Pour faciliter le montage et la fixation des LEDs je vais imprimer des rails en filament PLA blanc. J’aurais ainsi la possibilité d’y ajouter un diffuseur transparent sur chacun des rails lorsque j’aurais une bobine de filament transparent car le blanc rend trop opaque la lumière diffusée par les LEDs. Pour l’impression 3D, j’ai utilisé ce modèle :

Celui-ci est téléchargeable sur le site Thingiverse. J’ai ainsi des rails de 170 mm x 13 mm qui contiendra un bandeau de 5 LEDs. Pour le dernier rail je n’aurais rien à effectuer, par contre pour les autres je serais dans l’obligation de donner un coup de cutter pour y laisser passer les 3 fils pour le chainage du bandeau.

Donc je vais partir sur 4 rails contenant chacun un bandeau de 5 LEDs.

L’ampérage nécessaire pour l’alimentation de l’Arduino pro mini et les LEDS sera le suivant :

  • Arduino pro mini : 150 mA
  • Bandeau LEDs : 3 LED RGB * 20mA = 60 mA max par module LED pour une couleur blanche et la luminosité au maximum. J’ai 4 bandeau de 5 LEDs donc 20 LEDs au total donc pour la consommation maximum : 20 * 60 mA = 1.2 A.

Ce qui permet de définir qu’il me faut un adaptateur 5v – 1.4A ne prenant pas trop de place pour le loger dans la lampe car je veux garder l’arrivée 220v qui passe dans les bras et qui est connectée à un interrupteur en haut de la lampe.

J’ai démonté un chargeur 5v 2A :

J’ai repéré l’arrivée du 220v et la sortie 5v. Par contre aucun moyen de fixation donc je vais partir sur l’utilisation de colzons. C’est pas pro mais cela fera l’affaire.

Le schéma électronique sera le suivant :

Pour la télécommande, mon choix a été celui-ci :

Comme j’ai des LEDs RGB, je peux aisément utiliser la télécommande pour sélectionner la couleur à afficher.

Voici le montage que j’ai effectué sur une plaque d’essai :

Je n’avais pas d’autres choix que fixer l’alimentation avec un colzon; vue de derrière pour la fixation dans l’emplacement de la lampe :

Passons donc au collage des rails au fond de la lampe et l’installation des 4 bandeaux de LEDs :

Maintenant passons au programme, relativement simple qui s’apuie sur l’utilisation de 2 librairies :

  • irremote pour la gestion de l’infrarouge.
  • Neopixel d’Adafruit pour la gestion du bandeau de LED.

Pour connaître les codes générés par la télécommande il suffit de décommenter dans la boucle la ligne Serial.println et d’ouvrir le moniteur série de l’IDE Arduino.

Voici le contenu du programme :

/*
   Lampe bureau

   Programme qui permet de gérer 15 LED WS2812b à partir d'une télécommande
   Montage effectué pour une lampe de bureau

   Matériel : Arduino Pro Mini 5V-16 MHz
              Un récepteur infrarouge
              Bandeau WS2812b 15 Leds
              Télécommande infrarouge Magic Lighting

   Auteur : iTechnoFrance
*/

#include
#include 

// Définition des codes de la télécommande
#define t_on              0xFFE01F
#define t_off             0xFF609F
#define t_lum_moins       0xFF20DF
#define t_lum_plus        0xFFA05F
#define t_blanc           0xFFD02F
#define t_bleu_fonce      0xFF50AF
#define t_bleu            0xFF708F
#define t_bleu_ciel       0xFF28D7
#define t_bleu_mer        0xFF18E7
#define t_bleu_mer_fonce  0xFF08F7
#define t_vert            0xFF10EF
#define t_vert_clair      0xFF30CF
#define t_violet          0xFF6897
#define t_violet_clair    0xFF58A7
#define t_rose            0xFF48B7
#define t_rouge           0xFF906F
#define t_rouge_clair     0xFFB04F
#define t_orange          0xFFA857
#define t_orange_clair    0xFF9867
#define t_jaune           0xFF8877

// Définition réception infrarouge
#define broche_reception  11  // broche 11 données capteur infrarouge
IRrecv reception_ir(broche_reception);  // crée une instance
decode_results decode_ir;  // stockage données reçues

// Définition Neopixel
#define broche_neopixel  6  // broche 6 vers IN du bandeau LED
#define nbr_pixels  20  // définit le nombre de pixels
int luminosite = 127;  // définit la luminosité
byte rouge = 127;
byte vert = 127;
byte bleu = 127;
boolean allume = true;
Adafruit_NeoPixel bandeau = Adafruit_NeoPixel(nbr_pixels, broche_neopixel, NEO_GRB + NEO_KHZ800);

void affiche()
{
  for(int i=0; i<nbr_pixels;i++)
  {
    bandeau.setPixelColor(i, bandeau.Color(rouge, vert, bleu));
  }
  bandeau.show();
}

void setup()
{
  Serial.begin(9600);
  reception_ir.enableIRIn();  // démarre la réception infrarouge
  bandeau.setBrightness(luminosite);
  bandeau.begin();
  affiche();  // allume le bandeau en blanc
}

void loop()
{
  if (reception_ir.decode(&decode_ir))
  {
    switch (decode_ir.value)
    {
      case t_on:
        allume = true;
        luminosite = 127;
        bandeau.setBrightness(luminosite);
        rouge = 127;
        vert = 127;
        bleu = 127;
        affiche();
        break;
      case t_off:
        allume = false;
        rouge = 0;
        vert = 0;
        bleu = 0;
        affiche();
        break;
      case t_lum_moins:
        if (allume)
        {
          luminosite -= 20;
          if (luminosite  255)
          { luminosite = 255; }
          bandeau.setBrightness(luminosite);
          affiche();
        }
        break;
      case t_blanc:
        if (allume)
        {
          rouge = 255; vert = 255; bleu = 255;
          affiche();
        }
        break;
      case t_bleu_fonce:
        if (allume)
        {
          rouge = 0; vert = 0; bleu = 255;
          affiche();
        }
        break;
      case t_bleu:
        if (allume)
        {
          rouge = 0; vert = 102; bleu = 204;
          affiche();
        }
        break;
      case t_bleu_ciel:
        if (allume)
        {
          rouge = 0; vert = 255; bleu = 255;
          affiche();
        }
        break;
      case t_bleu_mer:
        if (allume)
        {
          rouge = 0; vert = 51; bleu = 102;
          affiche();
        }
        break;
      case t_bleu_mer_fonce:
        if (allume)
        {
          rouge = 0; vert = 0; bleu = 102;
          affiche();
        }
        break;
      case t_violet:
        if (allume)
        {
          rouge = 51; vert = 0; bleu = 102;
          affiche();
        }
        break;
      case t_violet_clair:
        if (allume)
        {
          rouge = 255; vert = 0; bleu = 51;
          affiche();
        }
        break;
      case t_rose:
        if (allume)
        {
          rouge = 255; vert = 51; bleu = 153;
          affiche();
        }
        break;
      case t_vert:
        if (allume)
        {
          rouge = 0; vert = 255; bleu = 0;
          affiche();
        }
        break;
      case t_vert_clair:
        if (allume)
        {
          rouge = 128; vert = 255; bleu = 0;
          affiche();
        }
        break;
      case t_rouge:
        if (allume)
        {
          rouge = 255; vert = 0; bleu = 0;
          affiche();
        }
        break;
      case t_rouge_clair:
        if (allume)
        {
          rouge = 153; vert = 5; bleu = 0;
          affiche();
        }
        break;
      case t_orange:
        if (allume)
        {
          rouge = 255; vert = 20; bleu = 0;
          affiche();
        }
        break;
      case t_orange_clair:
        if (allume)
        {
          rouge = 255; vert = 40; bleu = 0;
          affiche();
        }
        break;
      case t_jaune:
        if (allume)
        {
          rouge = 255; vert = 100; bleu = 0;
          affiche();
        }
        break;
      default:
        break;
    }
    //Serial.println(decode_ir.value, HEX);  // Affiche le code télécommande
    reception_ir.resume(); // reçoit le prochain code
  }
}

Reste plus qu'à tester :

Cela fonctionne, je peux remonter la lampe de bureau et commencer à travailler sur mon ordinateur…

Une démo du fonctionnement est disponible sur ma chaîne Youtube.

  1. Aucun commentaire pour l’instant.
  1. No trackbacks yet.

Votre commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l’aide de votre compte WordPress.com. Déconnexion /  Changer )

Photo Google

Vous commentez à l’aide de votre compte Google. Déconnexion /  Changer )

Image Twitter

Vous commentez à l’aide de votre compte Twitter. Déconnexion /  Changer )

Photo Facebook

Vous commentez à l’aide de votre compte Facebook. Déconnexion /  Changer )

Connexion à %s

%d blogueurs aiment cette page :