Assista no YouTube

Projeto de Relógio de Internet com Matriz de LED RGB ESP32-S3 - 4 Cores Aleatórias

Relógio Internet ESP32-S3 com Cores RGB Aleatórias

Este projeto é um relógio de Internet com matriz RGB ESP32-S3 que se conecta ao Wi-Fi, sincroniza a hora local de um servidor NTP e exibe a hora em rolagem.HH:MMformato na matriz RGB NeoMatrix 8×8 integrada. Nesta versão, as horas, o dois-pontos e os minutos são renderizados emcores aleatóriasselecionado em cada ciclo de rolagem completo, criando uma exibição de relógio dinâmica e lúdica que muda constantemente.

Como funciona este relógio

Depois de alimentar a placa via USB-C, o ESP32-S3 se conecta à sua rede Wi-Fi e recupera a hora local atual da internet. O tempo é dividido em três partes: horas, dois pontos e minutos, e cada parte é desenhada separadamente na matriz RGB. Quando o texto rola completamente para fora da tela, novas cores aleatórias são escolhidas para a próxima passagem.

Bibliotecas usadas

Este esboço utiliza as seguintes bibliotecas:

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

InstalarAdafruit NeoMatrixa partir do Gerenciador de Bibliotecas do Arduino. Dependências necessárias, comoAdafruit GFX LibraryeAdafruit NeoPixelserá instalado automaticamente.

Configuração importante do usuário

Pino de dados da matriz (matriz RGB integrada)

Embora a matriz RGB esteja integrada na placa, o pino de dados ainda deve ser definido no código:

#define MATRIX_PIN 14

GPIO 14 é comumente utilizado em placas de matriz RGB ESP32-S3. Se a variante da sua placa usar um pino diferente, atualize este valor de acordo.

SSID e senha do Wi-Fi (sensíveis a maiúsculas e minúsculas)

Substitua as credenciais de Wi-Fi pelos detalhes da sua própria rede:

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

Importante:Os SSIDs do Wi-Fi sãosensible a maiúsculas e minúsculasUm SSID chamado"Book"não é o mesmo que"book"Se a capitalização não corresponder exatamente, o ESP32-S3 falhará ao conectar.

Servidor NTP, fuso horário e horário de verão

A sincronização de tempo é feita usando um servidor NTP da internet:

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

A hora local é calculada usando o UTC e os deslocamentos de horário de verão:

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

• gmtOffset_sec: Deslocamento UTC em segundos (ajuste para a sua localização)
• daylightOffset_sec: Usar3600quando o horário de verão está ativo, ou0caso contrário

Essas configurações são aplicadas usando:

configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);

Brilho automático dia/noite

O relógio ajusta automaticamente o brilho com base na hora atual:

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

Entre 22h e 6h, o display diminui a intensidade para reduzir o brilho em ambientes escuros. Durante o dia, a matriz volta ao brilho normal.

Comportamento aleatório de cor RGB

Uma lista predefinida de cores RGB é armazenada em um array, onde cada cor é definida usando valores de Vermelho, Verde e Azul variando de 0 a 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
};

Em cada ciclo completo de rolagem:

• Thedígitos de horasão atribuídas uma cor aleatória
• Odois pontosrecebe uma cor aleatória diferente
• Theminutos dígitosreceber outra cor aleatória

Isso produz uma combinação de cores em constante mudança que mantém o relógio visualmente interessante. Para criar suas próprias cores personalizadas, você pode usar a ferramenta Seletor de Cores RGB:Selecione Cor RGB.

Lógica de renderização de tempo

O tempo é dividido em três componentes:

• Horas: HH
• Dois pontos: :
• Minutos: MM

Cada parte é desenhada individualmente para que possa ter sua própria cor, enquanto todas as partes se movem juntas para formar uma animação de rolagem suave na tela 8×8.

Geração de cor aleatória

Para garantir a aleatoriedade da cor, o esboço inicializa o gerador de números aleatórios na inicialização usando um pino analógico não conectado:

randomSeed(analogRead(0));

Isso garante que as combinações de cores sejam diferentes em cada power-up e em cada ciclo de rolagem.

Demonstração

Após fazer o upload do esboço e alimentar a placa via USB-C:

• O ESP32-S3 conecta-se à sua rede Wi-Fi.
• O tempo é sincronizado pela internet.
• O tempo rola para dentroHH:MMformato
• Horas, dois pontos e minutos mudam para cores aleatórias a cada ciclo
• O display escurece automaticamente à noite.

Downloads e links

O código fonte completo é fornecido abaixo deste artigo. Ferramentas úteis e referências estão vinculadas abaixo deste artigo.

Imagens

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

/*
 * =====================================================================================
 * RELÓGIO RGB INTERNET ESP32-S3 (Matriz 8x8) - Projeto 4 - Cor Aleatória
 * =====================================================================================
 * assista o vídeo https://youtube.com/shorts/4iWjLiD7fS8
 * 📚⬇️ Página de download e recursos https://robojax.com/RJT838
 * Autor: Gemini (Parceiro de Pensamento AI) & Ahmad Shamshiri (Robojax.com)
 * Data: 07 Jan 2026
 * 
 * CARACTERÍSTICAS:
 * 1. Hora WiFi/NTP: Sincroniza automaticamente com servidores de tempo da internet.
 * 2. Cor Baseada em Ciclo: A cor muda SOMENTE após o tempo terminar um ciclo completo de rolagem.
 * 3. Brilho Automático: Reduz o brilho dos LEDs durante as horas noturnas (Configuração pelo usuário).
 * =====================================================================================
 * 
 * =====================================================================================
 * RELÓGIO INTERNET ESP32-S3 - ELEMENTOS MULTICOR
 * =====================================================================================
 * Cada parte do tempo (HH : MM) recebe uma cor aleatória diferente da sua lista.
 * As cores só mudam uma vez que o ciclo completo de rolagem é concluído.
 * =====================================================================================
 */
#include <WiFi.h>
#include "time.h"
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#define MATRIX_PIN 14

 // --- CONFIGURAÇÃO ---
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}, // Vermelho
  {0, 255, 0}, // Verde
  {0, 0, 255}, // Azul
  {255, 165, 0}, // Laranja
  {255, 0, 255}, // Magenta
  {0, 255, 255}, // Ciano
  {255, 255, 0} // Amarelo
};
int totalColors = sizeof(userColors) / sizeof(userColors[0]);

 // Variáveis para armazenar os índices da cor aleatória atual
int hourColorIdx = 0;
int colonColorIdx = 1;
int minColorIdx = 2;

 // --- GLOBAIS ---
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;

 // 👇 SUBSTITUA isso pelo seu verdadeiro nome e senha da rede WiFi doméstica
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. Horas de Desenho
  matrix.setTextColor(matrix.Color(userColors[hourColorIdx][0], userColors[hourColorIdx][1], userColors[hourColorIdx][2]));
  matrix.setCursor(x, 0);
  matrix.print(hourText);
  x += 12; // Mover 12 pixels (2 dígitos * 6px)

 // 2. Desenhe o cólon
  matrix.setTextColor(matrix.Color(userColors[colonColorIdx][0], userColors[colonColorIdx][1], userColors[colonColorIdx][2]));
  matrix.setCursor(x, 0);
  matrix.print(":");
  x += 6; // Mover 6 pixels

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

  matrix.show();
  scrollX--;

 // A largura total é de aproximadamente 30 pixels (HH=12, :=6, MM=12)
  if (scrollX < -30) {
    scrollX = matrix.width();

 // Escolha NOVAS cores aleatórias para o próximo ciclo
    hourColorIdx = random(0, totalColors);
    colonColorIdx = random(0, totalColors);
    minColorIdx = random(0, totalColors);
  }
}

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

 // Semear o gerador aleatório usando um pino analógico não conectado
  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();
  }
}