J’ai récemment monté un nouveau PC trouvé dans les poubelles avec des ventilateurs RGB vraiment sympas, mais malheureusement, la carte mère est un peu ancienne et ne dispose pas de header ARGB. Plutôt que d’acheter un contrôleur ARGB tout fait, j’ai décidé d’en fabriquer un moi-même avec un Arduino Nano qui traînait dans mes tiroirs. Voici comment j’ai procédé !

Câblage

L’avantage de l’Arduino Nano, outre sa taille facile à glisser dans un boîtier, est qu’il fonctionne en 5 V. Il est donc facile de l’alimenter avec un câble Molex ou en USB.

Le câblage est très simple, le seul composant additionnel requis est une résistance de 470 ohms. Le pin D2 transmet le signal ARGB aux ventilateurs et le pin D3 est connecté au bouton Reset du PC qui servira plus tard à contrôler l’éclairage. Il est possible d’alimenter l’Arduino en 5V depuis l’alimentation du PC ou bien d’utiliser en câble USB.

L’Arduino peut être collé facilement avec un adhésif double face. Pour ma part j’ai utilisé une bande Command 3M ce qui permet de le détacher pour le reprogrammer puis le replacer par la suite. L’important est que l’adhésif soit suffisamment épais pour éviter tout court-circuit avec le métal du boitier.

Code

Pour piloter les LEDs, j’ai utilisé la bibliothèque FastLED, qui est une référence pour contrôler des LEDs adressables. Elle supporte une tonne de modèles de LEDs (WS2812B, WS2811, APA102, etc.) et offre des fonctions très pratiques pour créer des animations.

Installation de FastLED

Dans l’IDE Arduino :

1. Croquis → Inclure une bibliothèque → Gérer les bibliothèques
2. Rechercher « FastLED »
3. Installer la dernière version

Exemple simple

Voici un bout de code pour tester que tout fonctionne. Les LEDs devraient toutes s’allumer en blanc. Pensez à modifier le nombre de LED et le type (les WS2812B sont très répandues).

#include <FastLED.h>

#define NUM_LEDS 8         // 8 LEDs
#define DATA_PIN 2         // Pin de données
#define LED_TYPE WS2812B   // Type de LED
#define COLOR_ORDER GRB    // Ordre des couleurs (important !)

CRGB leds[NUM_LEDS];

void setup() {
  FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, NUM_LEDS);
  FastLED.setBrightness(255);
}

Réglage de la colorimétrie

Ce premier test a été plutôt… décevant. Pour du blanc pur (255, 255, 255), j’ai obtenu une couleur dans les bleu-rose.

Après quelques recherches, j’ai découvert que les LEDs WS2812B bon marché (comme celles de mes ventilateurs) ont souvent des composantes RGB très mal équilibrées.

La solution : FastLED.setCorrection()

FastLED dispose d’une fonction pratique qui permet de corriger automatiquement ces déséquilibres : FastLED.setCorrection(). Il suffit de lui passer une valeur hexadécimale qui compense les défauts de vos LEDs.

FastLED.setCorrection(0xFFD750);  // Ma correction personnalisée

Pour trouver la bonne valeur, il n’y a qu’une seule solution : faire des essais successifs jusqu’à trouver une bonne valeur d’équilibre. Cela demande beaucoup de patience mais le résultat final sera à la hauteur de vos attentes !

Astuce : Déterminer automatiquement le nombre de LEDs

Au début, je n’étais pas sûr du nombre de LEDs de mes ventilateurs. Il n’existe pas de documentation détaillée pour mes ventilateurs donc j’ai créé un petit programme de test qui allume chaque LED une par une :

#include <FastLED.h>

#define MAX_LEDS 255        // Maximum possible
#define DATA_PIN 2
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
#define DELAY_MS 200        // Délai entre chaque LED (en millisecondes)

CRGB leds[MAX_LEDS];

void setup() {
  FastLED.addLeds<LED_TYPE, DATA_PIN, COLOR_ORDER>(leds, MAX_LEDS);
  FastLED.setBrightness(100);  // Luminosité moyenne pour le test
  FastLED.clear();
  FastLED.show();
}

void loop() {
  // Allume chaque LED successivement en rouge
  for (int i = 0; i < MAX_LEDS; i++) {
    FastLED.clear();           // Éteint toutes les LEDs
    leds[i] = CRGB::Red;       // Allume la LED courante en rouge
    FastLED.show();
    delay(DELAY_MS);
    
    // Si vous voyez cette LED s'allumer, notez son numéro !
    // Le comptage commence à 0, donc LED 0 = première LED
  }
  
  // Pause avant de recommencer
  FastLED.clear();
  FastLED.show();
  delay(2000);
}

Création d’une animation « Fleurs de cerisier »

Une fois la base fonctionnelle, je voulais créer quelque chose de visuellement agréable. J’ai opté pour un effet « fleurs de cerisier » (sakura) avec des tons roses qui se déplacent doucement le long des LEDs.

Le concept

L’idée est simple : générer aléatoirement des couleurs dans les tons roses pastel, puis les faire circuler d’une LED à l’autre avec des transitions fluides. Ça donne l’impression de pétales qui flottent au vent.

Génération des couleurs

CRGB generateBlossomColor() {
  byte hue = random(220, 256);    // Teintes rose-rouge
  byte sat = random(50, 130);     // Saturation basse = effet pastel
  byte val = random(200, 255);    // Luminosité douce
  return CHSV(hue, sat, val);
}

J’utilise le modèle HSV (Teinte, Saturation, Valeur) plutôt que RGB car c’est beaucoup plus intuitif pour créer des palettes de couleurs. Les valeurs aléatoires donnent un côté organique très sympa.

Animation fluide avec interpolation

Le secret d’une animation fluide, c’est l’interpolation. Au lieu de changer brutalement de couleur, je fais une transition progressive :

CRGB color1 = colors[i];
CRGB color2 = colors[i + 1];
leds[i] = color1 % (255 * (1 - position)) + color2 % (255 * position);

La variable position varie de 0 à 1, créant une transition en douceur. J’incrémente cette position à chaque frame avec un petit FADE_STEP de 0.003, ce qui donne une animation très lente et hypnotique.

Contrôle de la luminosité avec le bouton du boîtier

La dernière amélioration, et pas des moindres : pouvoir contrôler la luminosité sans avoir à reprogrammer l’Arduino. J’ai utilisé le bouton Reset de mon boîtier (celui qui sert normalement à réinitialiser le PC mais qui fait double emploi avec le bouton Power) pour cycler entre différents niveaux de luminosité.

Connexion du bouton

Le bouton reset de la plupart des boîtiers PC a deux fils : un signal et une masse. Je les ai connectés à la pin D3 de l’Arduino (avec la résistance pull-up interne activée) et au GND.

pinMode(BUTTON_PIN, INPUT_PULLUP);

Niveaux de luminosité

J’ai défini 6 niveaux de luminosité : 100%, OFF, 20%, 40%, 60%, 80%. À chaque pression sur le bouton, on passe au niveau suivant.

const uint8_t brightnessLevels[] = { 255, 0, 51, 102, 153, 204 };

Sauvegarde en EEPROM

Enfin, le niveau de luminosité est sauvegardé dans l’EEPROM de l’Arduino. Comme ça, quand j’éteins et rallume mon PC, la luminosité reste celle que j’avais choisie !

EEPROM.update(EEPROM_BRIGHTNESS_ADDR, brightnessIndex);

Le code complet

Voici le code complet que j’utilise actuellement sur mon PC. N’oubliez pas d’adapter NUM_LEDS selon votre configuration ! Il est disponible dans ce gist : https://gist.github.com/LenweSaralonde/3ded8133064a41106923e75b11ee9269

Résultat final

Le résultat est franchement stylé, surtout pour du matériel d’entrée de gamme et issue en grande partie de récupération.

Ça claque, hein ?

Personnalisation

Il est possible de modifier très simplement le code pour donner un tout autre style :

Autres effets de couleurs :

• Bleu glacier : hue = random(140, 180)
• Coucher de soleil : hue = random(0, 40)
• Arc-en-ciel : hue = random(0, 255)

Vitesse d’animation :

• Animation rapide : FADE_STEP = 0.01
• Animation ultra lente : FADE_STEP = 0.001

Il est aussi possible d’utiliser le bouton pour switcher entre différents patterns et couleurs. La seule limite est votre imagination !