Regarder sur YouTube

Projet d'horloge Internet avec matrice LED RVB ESP32-S3 - 4 couleurs aléatoires

Horloge Internet ESP32-S3 avec couleurs RGB aléatoires

Ce projet est une horloge Internet RGB Matrix ESP32-S3 qui se connecte au Wi-Fi, synchronise l'heure locale à partir d'un serveur NTP et fait défiler l'heure dansHH:MMformat à travers le NeoMatrix RGB 8×8 intégré. Dans cette version, les heures, le deux-points et les minutes sont chacun rendus encouleurs aléatoiressélectionné à chaque cycle de défilement complet, créant un affichage d'horloge dynamique et ludique qui change constamment.

Comment fonctionne cette horloge

Après avoir alimenté la carte via USB-C, l'ESP32-S3 se connecte à votre réseau Wi-Fi et récupère l'heure locale actuelle depuis Internet. L'heure est divisée en trois parties : heures, deux-points et minutes, et chaque partie est affichée séparément sur la matrice RGB. Lorsque le texte défile complètement hors de l'écran, de nouvelles couleurs aléatoires sont choisies pour le passage suivant.

Bibliothèques utilisées

Ce croquis utilise les bibliothèques suivantes :

#include <WiFi.h>
#include "time.h"
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

InstallerAdafruit NeoMatrixdepuis le Gestionnaire de bibliothèques Arduino. Les dépendances requises commeAdafruit GFX LibraryetAdafruit NeoPixelsera installé automatiquement.

Configuration utilisateur importante

Données de broche matrice (matrice RVB intégrée)

Bien que la matrice RGB soit intégrée sur la carte, la broche de données doit toujours être définie dans le code :

#define MATRIX_PIN 14

Le GPIO 14 est couramment utilisé sur les cartes matrice RGB ESP32-S3. Si votre variante de carte utilise une broche différente, mettez à jour cette valeur en conséquence.

SSID Wi-Fi et mot de passe (sensible à la casse)

Remplacez les informations d'identification Wi-Fi par les détails de votre propre réseau :

const char* WIFI_SSID     = "your WiFi SSID";
const char* WIFI_PASSWORD = "passW0rd";

Important :Les SSID Wi-Fi sontsensible à la casse. Un SSID nommé"Book"n'est pas la même chose que"book"Si la capitalisation ne correspond pas exactement, l'ESP32-S3 échouera à se connecter.

Serveur NTP, fuseau horaire et heure d'été

La synchronisation de l'heure se fait en utilisant un serveur NTP sur Internet :

const char* ntpServer = "pool.ntp.org";

L'heure locale est calculée en utilisant UTC et les décalages pour l'heure d'été :

// Toronto-ish: UTC-5, plus 1 hour DST
const long  gmtOffset_sec     = -5 * 3600;
const int   daylightOffset_sec = 3600;

• gmtOffset_secDécalage UTC en secondes (ajustez pour votre emplacement)
• daylightOffset_secUtiliser3600lorsque l'heure d'été est active, ou0sinon

Ces paramètres sont appliqués en utilisant :

configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);

Luminosité automatique jour/nuit

L'horloge ajuste automatiquement la luminosité en fonction de l'heure actuelle :

const int DAY_BRIGHTNESS = 40;
const int NIGHT_BRIGHTNESS = 5;
const int NIGHT_START_HOUR = 22;
const int NIGHT_END_HOUR = 6;

Entre 22 h et 6 h, l'écran s'assombrit pour réduire l'éblouissement dans des environnements sombres. Pendant les heures de jour, la matrice retrouve une luminosité normale.

Comportement aléatoire des couleurs RGB

Une liste prédéfinie de couleurs RGB est stockée dans un tableau, où chaque couleur est définie à l'aide des valeurs Rouge, Vert et Bleu variant de 0 à 255 :

uint8_t userColors[][3] = {
  {255, 0, 0},    // Red
  {0, 255, 0},    // Green
  {0, 0, 255},    // Blue
  {255, 165, 0},  // Orange
  {255, 0, 255},  // Magenta
  {0, 255, 255},  // Cyan
  {255, 255, 0}   // Yellow
};

À chaque cycle complet de défilement :

• Lechiffres d'heuresont attribuées une couleur aléatoire
• Ledeux-pointsreçoit une couleur aléatoire différente
• Leminutes chiffresrecevoir une autre couleur aléatoire

Cela produit une combinaison de couleurs en constante évolution qui rend l'horloge visuellement intéressante. Pour créer vos propres couleurs personnalisées, vous pouvez utiliser l'outil Sélecteur de couleurs RGB :Sélecteur de couleurs RVB.

Logique de rendu temporel

Le temps est divisé en trois composants :

• Heures : HH
• Colon : :
• Minutes : MM

Chaque partie est dessinée individuellement afin qu'elle puisse avoir sa propre couleur, tandis que toutes les parties se déplacent ensemble pour former une animation de défilement fluide sur l'écran 8×8.

Génération de couleurs aléatoires

Pour garantir l'aléatoire des couleurs, le croquis initialise le générateur de nombres aléatoires au démarrage en utilisant une broche analogique non connectée :

randomSeed(analogRead(0));

Cela garantit que les combinaisons de couleurs sont différentes à chaque power-up et à chaque cycle de défilement.

Démonstration

Après avoir téléchargé le croquis et alimenté la carte via USB-C :

• L'ESP32-S3 se connecte à votre réseau Wi-Fi.
• L'heure est synchronisée depuis internet.
• Le temps défile.HH:MMformat
• Les heures, les deux-points et les minutes changent de couleurs aléatoires à chaque cycle.
• L'écran s'assombrit automatiquement la nuit.

Téléchargements et liens

Le code source complet est fourni ci-dessous dans cet article. Des outils utiles et des références sont liés ci-dessous dans cet article.

Images

ESP32 S3 Matrix

ESP32 S3 Matrix pin out

ESP32-S3_RGB_8x8_matrix-3

ESP32-S3_RGB_8x8_matrix1

ESP32-S3_RGB_8x8_matrix-2

ESP32-s3_internet_clock_animation

ESP32 S3 Matrix

ESP32 S3 Matrix pin out

ESP32-S3_RGB_8x8_matrix-3

ESP32-S3_RGB_8x8_matrix1

ESP32-S3_RGB_8x8_matrix-2

ESP32-s3_internet_clock_animation

/*
 * =====================================================================================
 * HORLOGE RGB INTERNET ESP32-S3 (Matrice 8x8) - Projet 4 - Couleur Aléatoire
 * =====================================================================================
 * regarder la vidéo https://youtube.com/shorts/4iWjLiD7fS8
 * 📚⬇️ Page de téléchargement et ressources https://robojax.com/RJT838
 * Auteur : Gemini (Partenaire de Pensée AI) & Ahmad Shamshiri (Robojax.com)
 * Date : 07 Jan 2026
 * 
 * CARACTÉRISTIQUES :
 * 1. Heure WiFi/NTP : Synchronise automatiquement avec les serveurs de temps Internet.
 * 2. Couleur Basée sur Cycle : La couleur change UNIQUEMENT après que le temps a terminé un cycle complet.
 * 3. Auto-Luminosité : Réduit la luminosité des DEL pendant les heures nocturnes (configurable par l'utilisateur).
 * =====================================================================================
 * 
 * =====================================================================================
 * HORLOGE INTERNET ESP32-S3 - ÉLÉMENTS MULTICOULEURS
 * =====================================================================================
 * Chaque partie de l'heure (HH : MM) reçoit une couleur aléatoire différente de votre liste.
 * Les couleurs ne changent qu'une fois le cycle de défilement complet terminé.
 * =====================================================================================
 */
#include <WiFi.h>
#include "time.h"
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#define MATRIX_PIN 14

 // --- CONFIGURATION ---
const int DAY_BRIGHTNESS = 40;
const int NIGHT_BRIGHTNESS = 5;
const int NIGHT_START_HOUR = 22;
const int NIGHT_END_HOUR = 6;

uint8_t userColors[][3] = {
  {255, 0, 0}, // Rouge
  {0, 255, 0}, // Vert
  {0, 0, 255}, // Bleu
  {255, 165, 0}, // Orange
  {255, 0, 255}, // Magenta
  {0, 255, 255}, // Cyan
  {255, 255, 0} // Jaune
};
int totalColors = sizeof(userColors) / sizeof(userColors[0]);

 // Variables pour stocker les indices de couleur aléatoires actuels.
int hourColorIdx = 0;
int colonColorIdx = 1;
int minColorIdx = 2;

 // --- GLOBALES ---
Adafruit_NeoMatrix matrix(8, 8, MATRIX_PIN,
  NEO_MATRIX_TOP    + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS   + NEO_MATRIX_PROGRESSIVE,
  NEO_RGB           + NEO_KHZ800);

char hourText[3], minText[3];
int16_t scrollX = 8;
unsigned long lastScrollMs = 0;
const uint16_t scrollIntervalMs = 100;

 // 👇 REMPLACEZ-les par le vrai nom et mot de passe de votre WiFi à domicile
const char* WIFI_SSID     = "WiFi";
const char* WIFI_PASSWORD = "passW0rd";

void updateTimeParts() {
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) return;

  snprintf(hourText, sizeof(hourText), "%02d", timeinfo.tm_hour);
  snprintf(minText, sizeof(minText), "%02d", timeinfo.tm_min);

  if (timeinfo.tm_hour >= NIGHT_START_HOUR || timeinfo.tm_hour < NIGHT_END_HOUR) {
    matrix.setBrightness(NIGHT_BRIGHTNESS);
  } else {
    matrix.setBrightness(DAY_BRIGHTNESS);
  }
}

void scrollTime() {
  matrix.fillScreen(0);

  int x = scrollX;

 // 1. Heures de dessin
  matrix.setTextColor(matrix.Color(userColors[hourColorIdx][0], userColors[hourColorIdx][1], userColors[hourColorIdx][2]));
  matrix.setCursor(x, 0);
  matrix.print(hourText);
  x += 12; // Déplacez 12 pixels (2 chiffres * 6px)

 // 2. Dessiner un côlon
  matrix.setTextColor(matrix.Color(userColors[colonColorIdx][0], userColors[colonColorIdx][1], userColors[colonColorIdx][2]));
  matrix.setCursor(x, 0);
  matrix.print(":");
  x += 6; // Déplacer de 6 pixels

 // 3. Dessiner les minutes
  matrix.setTextColor(matrix.Color(userColors[minColorIdx][0], userColors[minColorIdx][1], userColors[minColorIdx][2]));
  matrix.setCursor(x, 0);
  matrix.print(minText);

  matrix.show();
  scrollX--;

 // La largeur totale est d'environ 30 pixels (HH=12, :=6, MM=12)
  if (scrollX < -30) {
    scrollX = matrix.width();

 // Choisissez de NOUVELLES couleurs aléatoires pour le prochain cycle.
    hourColorIdx = random(0, totalColors);
    colonColorIdx = random(0, totalColors);
    minColorIdx = random(0, totalColors);
  }
}

void setup() {
  Serial.begin(115200);

 // Générez une graine pour le générateur aléatoire en utilisant une broche analogique non connectée.
  randomSeed(analogRead(0));

  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  configTime(-5 * 3600, 3600, "pool.ntp.org");
  matrix.begin();
  matrix.setTextWrap(false);
  matrix.setBrightness(DAY_BRIGHTNESS);
}

void loop() {
  if (millis() % 1000 == 0) updateTimeParts();

  if (millis() - lastScrollMs >= scrollIntervalMs) {
    lastScrollMs = millis();
    scrollTime();
  }
}