Visão Geral do Projeto

Os seis projetos abordados neste tutorial:

• Projeto 1– Ponto Móvel (configuração básica de matriz)
• Projeto 2– Rolagem de texto na matriz 8 × 8
• Projeto 3– Texto HTTP: envie texto do seu telefone ou PC via Wi-Fi
• Projeto 4– Ponto Tilt, controlado pelo acelerômetro QMI8658
• Projeto 5– Seta Sempre Para Cima (ponteiro de orientação usando QMI8658)
• Projeto 6– Jogo de Alvo com campainha e controle de inclinação

Se você se perder em qualquer etapa, compare suas configurações com os trechos fornecidos para cada projeto abaixo.

Introdução

Os projetos começam com a animação mais simples possível (um único ponto em movimento) e gradualmente adicionam texto, controle Wi-Fi e, finalmente, interação baseada em sensores usando o acelerômetro QMI8658. Ao final, você entenderá como controlar a matriz de LED e reagir à orientação da placa.

Instalando placas ESP32-S3 no Arduino IDE

Antes de carregar qualquer código, instale o suporte oficial da placa ESP32 no Arduino IDE e selecione um perfil de placa ESP32-S3 (por exemplo, um módulo de desenvolvimento ESP32-S3). Isso garante que o tamanho da flash, a frequência e as configurações USB corretas sejam aplicadas durante a compilação e o carregamento.

Instalando as Bibliotecas Necessárias

As seguintes bibliotecas são necessárias para estes projetos:

• Adafruit NeoPixel
• Adafruit GFX
• Adafruit NeoMatrix
• QMI8658 (por Lahav Gahali)

Instale-os uma vez usando o Gerenciador de Bibliotecas do Arduino, depois você pode reutilizá-los para todos os seis projetos.

Sobre o Acelerômetro QMI8658

O QMI8658 é um IMU de 6 eixos que combina um acelerômetro de 3 eixos e um giroscópio de 3 eixos. Nestes projetos, os valores do acelerômetro são usados para detectar a inclinação e a orientação da placa.

Convenção de eixos utilizada em todos os projetos:

• X– esquerda / direita
• Y– para frente / para trás
• Z– vertical (para cima / para baixo)

Em todos os projetos baseados em inclinação, você configurará o alcance do acelerômetro e a taxa de dados de saída uma vez, e depois lerá os valores para mover um ponto, orientar uma seta ou controlar um jogo.

// Common QMI8658 configuration used in tilt projects
// (Projects 4, 5, and 6)

const auto ACC_RANGE   = QMI8658AccRange_2g;
const auto ACC_ODR     = QMI8658AccODR_31_25Hz;
const auto GYR_RANGE   = QMI8658GyrRange_256dps;
const auto GYR_ODR     = QMI8658GyrODR_31_25Hz;

// Sensitivity factor for converting tilt to pixels
const float TILT_TO_PIXEL_SCALE = 4.0f;   // increase for more sensitivity
    

Projeto 1 – Ponto Móvel (Configurações Básicas de Matriz)

Projeto 1 é uma animação simples de um ponto em movimento que verifica a fiação da sua matriz de LED e as configurações básicas do NeoMatrix. Você define as dimensões da matriz, o pino de dados, o brilho e a velocidade de movimento do ponto.

Configurações Principais

// Project 1 – Moving Dot (basic matrix setup)

// Matrix geometry
#define MATRIX_PIN       14
#define MATRIX_WIDTH      8
#define MATRIX_HEIGHT     8

// Layout (choose one; many boards use ZIGZAG or PROGRESSIVE)
#define MATRIX_LAYOUT  (NEO_MATRIX_TOP + NEO_MATRIX_LEFT + \
                        NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG)
// Alternative if needed:
// #define MATRIX_LAYOUT  (NEO_MATRIX_TOP + NEO_MATRIX_LEFT + \
//                         NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE)

// Visual parameters
const uint8_t  P1_BRIGHTNESS     = 40;         // overall brightness (0–255)
const uint16_t P1_DOT_COLOR      = matrix.Color(0, 255, 0); // green dot
const uint16_t P1_STEP_DELAY_MS  = 80;         // smaller = faster movement
    

Ao alterarP1_DOT_COLOReP1_STEP_DELAY_MS, você pode testar rapidamente diferentes cores e velocidades de animação.

Projeto 2 – Rolagem de Texto

Projeto 2 exibe texto em rolagem, comoRobojax. Você controla a própria mensagem, a direção da rolagem, a cor do texto e a velocidade. Este projeto introduz a renderização de texto em uma matriz muito pequena.

Configurações Principais

// Project 2 – Text Scroll

// Scrolling message
const char* P2_MESSAGE = "Robojax";

// Text color (R, G, B)
const uint16_t P2_TEXT_COLOR = matrix.Color(255, 0, 0);  // red text

// Scroll speed
const uint16_t P2_SCROLL_DELAY_MS = 70;  // smaller = faster scroll

// Scroll direction (you will use this in your logic)
// Possible values: -1 for left, +1 for right, or use an enum
const int8_t P2_SCROLL_DIR_X = -1;  // -1 = scroll left, +1 = scroll right
const int8_t P2_SCROLL_DIR_Y =  0;  //  0 = no vertical scroll
    

Se você posteriormente decidir rolar verticalmente (para cima ou para baixo), definaP2_SCROLL_DIR_Xpara0e useP2_SCROLL_DIR_Yem vez disso.

Projeto 3 – Mensagem de Celular (Controlada por Wi-Fi)

O Projeto 3 transforma o ESP32-S3 em um pequeno servidor web. Você se conecta à placa via Wi-Fi, abre sua página da web e digita uma mensagem. O texto, a cor e a velocidade de rolagem são então usados para acionar o mesmo efeito de rolagem de texto na matriz em tempo real.

Configurações de Wi-Fi e Mensagens de Texto

// Project 3 – HTTP Text

// Wi-Fi credentials (change to your own network)
const char* P3_WIFI_SSID     = "YourWiFiName";
const char* P3_WIFI_PASSWORD = "YourWiFiPassword";

// Default text before anything is sent from the browser
String P3_currentText = "Robojax";

// Default color for the HTTP-controlled text
uint16_t P3_TEXT_COLOR = matrix.Color(0, 255, 255); // cyan

// Scroll speed for HTTP text
uint16_t P3_SCROLL_DELAY_MS = 80;  // can be updated from web page

// Allowed scroll directions (used as options in the HTML form)
enum P3_Direction {
  P3_LEFT,
  P3_RIGHT,
  P3_UP,
  P3_DOWN
};
P3_Direction P3_scrollDirection = P3_LEFT;
    

Na página da web, o usuário escolhe a direção e a velocidade. Seu código simplesmente atualizaP3_scrollDirectioneP3_SCROLL_DELAY_MScom base nas opções selecionadas.

Projeto 4 – Ponto de Inclinação (Usando QMI8658)

Projeto 4 lê o acelerômetro QMI8658 e move um único ponto pela matriz de acordo com a inclinação da placa. Quando a placa está nivelada, o ponto fica no centro. Inclinar a placa move o ponto nessa direção.

`

Configurações de Matriz e Inclinação

// Project 4 – Tilt Dot

// Matrix geometry / brightness
#define MATRIX_PIN_TILT       14
#define MATRIX_WIDTH_TILT      8
#define MATRIX_HEIGHT_TILT     8

const uint8_t  P4_BRIGHTNESS   = 40;
const uint16_t P4_DOT_COLOR    = matrix.Color(0, 255, 0); // green
const uint16_t P4_UPDATE_DELAY = 30;  // ms between updates

// QMI8658 configuration (reuse from common settings if desired)
const auto P4_ACC_RANGE = QMI8658AccRange_2g;
const auto P4_ACC_ODR   = QMI8658AccODR_125Hz;

// Mapping accelerometer to pixel offset
// Negative sign may be adjusted depending on how the board is held
const float P4_TILT_SCALE_X = 3.5f; // affects left/right sensitivity
const float P4_TILT_SCALE_Y = 3.5f; // affects up/down sensitivity
    

Em seu código, você limita as leituras do acelerômetro a um intervalo como[-1, 1], multiplique-os porP4_TILT_SCALE_XeP4_TILT_SCALE_Y, e adicione-os às coordenadas do centro. Se o movimento parecer invertido, simplesmente inverta o sinal.

Projeto 5 – Seta Sempre para Cima

Projeto 5 exibe uma seta na matriz 8 × 8 que sempre aponta para o lado "superior" da placa. Quando você gira a placa, a seta gira para que aponte para o lado que está voltado para cima.

Configurações de Seta e Orientação

// Project 5 – Arrow Always Up

// Matrix brightness and color for the arrow
const uint8_t  P5_BRIGHTNESS     = 50;
const uint16_t P5_ARROW_COLOR    = matrix.Color(255, 150, 0);  // orange

// How often to update orientation
const uint16_t P5_UPDATE_DELAY_MS = 40;

// Tilt thresholds (in g) used to decide which side is "up"
// Adjust according to the board orientation in your video/demo
const float P5_TILT_THRESHOLD_LOW  = -0.25f;
const float P5_TILT_THRESHOLD_HIGH =  0.25f;

// Example mapping corners/sides based on accelerometer values
// (used in your logic to choose which arrow shape to draw)
/*
  ax, ay conditions (examples):
    ax >  P5_TILT_THRESHOLD_HIGH  -> USB side up
    ax <  P5_TILT_THRESHOLD_LOW   -> opposite USB side up
    ay >  P5_TILT_THRESHOLD_HIGH  -> one lateral side up
    ay <  P5_TILT_THRESHOLD_LOW   -> other lateral side up
*/
    

O desenho real da seta é implementado commatrix.drawPixel()ematrix.drawLine(). A parte principal é decidir qual orientação da seta usar com base nas zonas de inclinação definidas porP5_TILT_THRESHOLD_LOWeP5_TILT_THRESHOLD_HIGH.

Projeto 6 – Jogo de Mira (Controlado por Inclinação)

Projeto 6 é um pequeno jogo no qual você controla um ponto do jogador usando o acelerômetro, tenta movê-lo para um pixel alvo e recebe feedback tanto da matriz quanto de um buzzer quando você acerta o alvo.

Configurações de Jogo e Campainha

// Project 6 – Tilt-Based Target Game

// Matrix brightness
const uint8_t P6_BRIGHTNESS = 60;

// Colors for game elements
const uint16_t P6_PLAYER_COLOR    = matrix.Color(0, 255, 0);   // green
const uint16_t P6_TARGET_COLOR    = matrix.Color(255, 0, 0);   // red
const uint16_t P6_BACKGROUND_COLOR = matrix.Color(0, 0, 0);    // off
const uint16_t P6_HIT_FLASH_COLOR = matrix.Color(255, 255, 0); // yellow on hit

// Buzzer pin and timing
const int      P6_BUZZER_PIN       = 4;       // change if wired differently
const uint16_t P6_BUZZER_ON_MS     = 120;     // beep duration
const uint16_t P6_BUZZER_OFF_MS    = 80;      // pause between beeps
const uint8_t  P6_BUZZER_VOLUME    = 128;     // if using PWM, duty cycle (0–255)

// Movement and game timing
const uint16_t P6_UPDATE_DELAY_MS  = 35;      // game loop delay
const float    P6_TILT_SCALE_X     = 3.5f;    // convert tilt to pixels (left/right)
const float    P6_TILT_SCALE_Y     = 3.5f;    // convert tilt to pixels (up/down)

// Minimum distance in pixels to count as a "hit"
const uint8_t  P6_HIT_DISTANCE_MAX = 0;       // 0 = exact same pixel
    

Na lógica do jogo você irá:

• Leia o acelerômetro e mova o ponto do jogador por uma quantidade escalada.
• Limite a posição do jogador dentro da grade 8 × 8.
• Verifique se a posição do jogador corresponde à posição alvo (ou está dentro da distância permitida).
• Ao acertar, pisque a matriz usandoP6_HIT_FLASH_COLORe ative o buzzer usandoP6_BUZZER_ON_MSeP6_BUZZER_OFF_MS.
• Então mova o alvo para uma nova posição aleatória e continue.

Mapa de Pin

Conclusão

Estes seis projetos abrangem os blocos essenciais para trabalhar com a Matriz de LED RGB Waveshare ESP32-S3: controle básico de pixels, rolagem de texto, interação baseada em Wi-Fi e gráficos e jogos baseados em inclinação usando o acelerômetro QMI8658.

Você pode combinar essas ideias para criar seus próprios projetos, como placares, pequenos displays de status, minijogos ou painéis de notificação, todos acionados por inclinação, toque ou mensagens do seu telefone ou computador.