Arduino Uno R3 potenciometros controlando o pisca de leds rgb

13 sites

Este projeto utiliza um Arduino Uno R3 para ler a posição de um ou mais potenciômetros e
usar esses valores para controlar a velocidade de "pisca" (delay) e a intensidade/cor de um
LED RGB.

Componentes Necessários
1x Arduino Uno R3
1x LED RGB (Cátodo Comum recomendado)
1x Potenciômetro (10kΩ recomendado)
3x Resistores de 220Ω (para proteger os pinos R, G, B)
1x Protoboard e Jumpers

Montagem do Circuito
1. LED RGB: Conecte o pino longo (cátodo) ao GND do Arduino. Conecte os pinos R, G e B
através de resistores de 220Ω aos pinos digitais PWM (ex: 9, 10, 11).
2. Potenciômetro: Conecte as extremidades ao 5V e GND. Conecte o pino central (cursor)
ao pino analógico A0.

Código Arduino (Pisca Velocidade)

Este código lê o potenciômetro e ajusta o tempo de delay entre piscar.

cpp
// Pinos do LED RGB
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;
const int potPin = A0; // Pino do potenciômetro

void setup() {
Pergunte o que quiser
pinMode(redPin, OUTPUT);
 pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
[Link](9600);
}

void loop() {
int potValue = analogRead(potPin); // Lê valor 0-1023
int delayTime = map(potValue, 0, 1023, 50, 1000); // Mapeia para tempo de 5

// Pisca em branco (mistura R+G+B)

digitalWrite(redPin, HIGH);
digitalWrite(greenPin, HIGH);
digitalWrite(bluePin, HIGH);
delay(delayTime);

digitalWrite(redPin, LOW);
digitalWrite(greenPin, LOW);
digitalWrite(bluePin, LOW);
delay(delayTime);
}

Use o código com cuidado.

Explicação Técnica
analogRead(A0) : Lê a tensão no pino central do potenciômetro, convertendo-a para um
valor entre 0 e 1023.
map(val, 0, 1023, 50, 1000) : Converte o valor lido para um intervalo de tempo, onde o
giro altera a velocidade do pisca.
analogWrite(pin, valor) : Pode ser usada para controlar a intensidade das cores
individualmente (0 a 255) se desejar uma variação de cor junto com o pisca.
Cátodo Comum vs Anodo Comum: O código acima assume Cátodo Comum (liga com
HIGH). Se usar Anodo Comum, troque HIGH por LOW e vice-versa.

Dica: Você pode usar analogRead em A1, A2 e A3 com três potenciômetros diferentes para
controlar R, G e B separadamente.

Using Potentiometer to Control LED Blink blink a RGB LED - General Guidance - Arduino
Speed - Exhibition Forum
 Arduino Forum Arduino Forum

COMO CONTROLAR UM LED RGB

POR ARDUINO COM ...
YouTube

Mostrar tudo

ok

Se precisar de ajuda para expandir o projeto, como adicionar mais potenciômetros para
controlar as cores individualmente ou criar efeitos de transição (fade), aqui estão algumas
sugestões:

1. Controle de Cor Individual: Use 3 potenciômetros (conectados em A0, A1 e A2) para

definir a intensidade de Vermelho, Verde e Azul separadamente usando a função
analogWrite() .

2. Simulador Online: Você pode testar este circuito antes de montar fisicamente usando o
Tinkercad Circuits, que possui o Arduino Uno R3 e o LED RGB no catálogo.
3. Documentação: Para entender melhor as funções usadas, consulte a Referência Oficial
do Arduino.

Estou à disposição se tiver dúvidas sobre a montagem ou o código!

ok .. eu consigo controlar a cor rgb com apenas um potenciometro ? por exemplo

usando programação?

Sim, é absolutamente possível controlar as cores de um LED RGB usando apenas um

potenciômetro através de programação , mas de uma maneira ligeiramente diferente do
que controlar cada cor individualmente.

O potenciômetro não vai permitir que você selecione qualquer cor do espectro de uma vez,
mas você pode usá-lo para navegar por um conjunto predefinido de cores ou um espectro
gradual.
Estratégias de Controle com 1 Potenciômetro
Você pode usar o valor lido do potenciômetro (0 a 1023) para determinar a cor de algumas
formas:

Opção 1: Navegando por Cores Discretas (Pré-definidas)

Você pode dividir o intervalo do potenciômetro em seções e atribuir uma cor fixa a cada
seção.

0 a 255 = Vermelho
256 a 511 = Verde
512 a 767 = Azul
768 a 1023 = Branco

Opção 2: Navegando pelo Espectro RGB Gradualmente (Melhor Efeito)

Esta é a opção mais comum. Você mapeia o valor do potenciômetro para um "índice" que
determina a intensidade relativa de R, G e B, criando um efeito de transição de cor suave.

Exemplo de Código (Espectro Gradual)

Este código ajusta o LED para percorrer o espectro de cores (do vermelho ao verde, depois
ao azul, e voltando) à medida que você gira o potenciômetro.

cpp
// Pinos do LED RGB
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;
const int potPin = A0; // Pino do potenciômetro

void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
[Link](9600);
}

void loop() {
int sensorValue = analogRead(potPin); // Lê valor 0-1023

// Mapeia o valor para uma faixa de 0 a 765 (3 * 255)

int mappedValue = map(sensorValue, 0, 1023, 0, 765);
 int R = 0;
int G = 0;
int B = 0;

// Lógica para percorrer o espectro (R -> G -> B -> R...)

if (mappedValue < 255) {
// Transição de Vermelho total para Verde total
R = 255 - mappedValue;
G = mappedValue;
B = 0;
} else if (mappedValue < 510) {
// Transição de Verde total para Azul total
R = 0;
G = 255 - (mappedValue - 255);
B = mappedValue - 255;
} else {
// Transição de Azul total para Vermelho total
R = mappedValue - 510;
G = 0;
B = 255 - (mappedValue - 510);
}

// Define as cores usando PWM (0 a 255)

analogWrite(redPin, R);
analogWrite(greenPin, G);
analogWrite(bluePin, B);

delay(10); // Pequeno delay para estabilidade

}

Use o código com cuidado.

Como Funciona este Código

Mapeamento: O valor do potenciômetro (0-1023) é mapeado para um índice de 0 a 765
(que é 3 × 255, o número total de passos de cor).
Lógica Condicional: Usamos if/else if para determinar em qual "terço" do espectro
estamos.
analogWrite() : Esta função é crucial, pois permite controlar a intensidade (PWM) de
cada pino RGB, ao contrário de digitalWrite() que apenas liga/desliga.

Dessa forma, um único potenciômetro funciona como um "seletor de matiz" (hue

selector).
 certo .. eu tenho um modulo de led rgb destes usados no Arduino, sabe ? que
tem um led rgb e já tem os resistores no modulo .. então posso colocar direto es…

11 sites

Sim, exatamente. O uso desses módulos facilita muito a montagem, pois elimina a
necessidade de fios e resistores soltos na protoboard.

No entanto, é importante identificar qual modelo de módulo você possui, pois nem todos têm
resistores integrados:

Modelo KY-016 (LED de 5mm): Geralmente possui os três resistores de proteção

soldados diretamente na placa. Você pode conectá-lo diretamente aos pinos do Arduino.
Modelo KY-009 (LED SMD 5050): Geralmente não possui resistores integrados. Se o
seu módulo for este (o LED é quadradinho e plano), você ainda precisará colocar
resistores de 220Ω entre os pinos R, G, B e o Arduino para não queimar o componente.

Módulo Led RGB 5mm KY-016 Módulo Led RGB SMD 5050 KY-009
R$ 0,93/mês 6x R$ 4,74
4.9 (8) 4.8 (17)

Como conectar com o potenciômetro

A conexão segue a mesma lógica lógica de controle por software:

1. Potenciômetro: Conecte os pinos laterais ao 5V e GND, e o pino central ao A0 do

Arduino.
2. Módulo RGB:
1. Pino GND (ou - ) do módulo no GND do Arduino.
 2. Pinos R, G, B nos pinos digitais PWM (como 9, 10 e 11).
3. Programação: Use o código de "Espectro Gradual" enviado anteriormente. O Arduino lerá
a posição do potenciômetro (0 a 1023) e converterá esse número em intensidades
diferentes para os pinos R, G e B, permitindo que você "navegue" pelas cores girando o
botão.

Dica visual: Se o seu módulo tem três pequenos componentes pretos retangulares perto dos
pinos, esses são os resistores SMD e você pode ligar direto. Se a placa tiver apenas as trilhas
indo direto do pino para o LED, use resistores externos.

KY-016 - Modulo LED RGB | Módulo Led - Rgb Smd Ky-009

Arduino, ESP8266 e ...
YouTube · WS Gambis 10:18 Smart Componentes Eletronicos

LED RGB (Módulo) com Arduino e

Pictoblox - Aula 05
YouTube · Prof. Miquéias Serrão 5:01

Mostrar tudo

》
sim , é este que eu tenho Modelo KY-016 (LED de 5mm): Geralmente possui os
três resistores de proteção soldados diretamente na placa. Você pode conectá-l…

Excelente! Isso simplifica bastante a montagem.

Como o módulo KY-016 já possui os resistores integrados, você não precisa se preocupar
com a proteção do LED.

Aqui está um resumo da conexão e o código novamente para referência, garantindo que tudo
funcione perfeitamente.

Conexões Físicas (Módulo KY-016)

Módulo KY-016 Pino Arduino Uno Pino

GND (ou - ) GND

R (Vermelho) Digital 9 (PWM)

G (Verde) Digital 10 (PWM)

B (Azul) Digital 11 (PWM)

Potenciômetro Pino Arduino Uno Pino

Lateral 1 5V

Central (Cursor) A0 (Analógico 0)

Lateral 2 GND

Código Arduino para Controle de Espectro com 1 Potenciômetro

Carregue este código no seu Arduino para navegar pelo espectro de cores (vermelho, verde,
azul e transições) usando o giro do potenciômetro:

cpp
// Pinos do LED RGB conectados ao módulo KY-016
const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;
const int potPin = A0; // Pino do potenciômetro

void setup() {
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
// Opcional: inicie o monitor serial para ver os valores
[Link](9600);
}

void loop() {
int sensorValue = analogRead(potPin); // Lê valor de 0 a 1023

// Mapeia o valor para uma faixa de 0 a 765 (3 * 255)

int mappedValue = map(sensorValue, 0, 1023, 0, 765);

int R = 0;
int G = 0;
int B = 0;
 // Lógica para percorrer o espectro de cores: R -> G -> B -> R
if (mappedValue < 255) {
// 0 a 254: Vermelho total diminuindo, Verde aumentando
R = 255 - mappedValue;
G = mappedValue;
B = 0;
} else if (mappedValue < 510) {
// 255 a 509: Verde total diminuindo, Azul aumentando
R = 0;
G = 255 - (mappedValue - 255);
B = mappedValue - 255;
} else {
// 510 a 765: Azul total diminuindo, Vermelho aumentando
R = mappedValue - 510;
G = 0;
B = 255 - (mappedValue - 510);
}

// Aplica as intensidades (PWM) nos pinos do Arduino

analogWrite(redPin, R);
analogWrite(greenPin, G);
analogWrite(bluePin, B);

// Opcional: Imprime os valores atuais no Monitor Serial

// [Link]("R: "); [Link](R);
// [Link](" G: "); [Link](G);
// [Link](" B: "); [Link](B);

delay(10); // Pequeno delay para estabilidade da leitura

}

Use o código com cuidado.

Agora você tem um controle de cores totalmente funcional com apenas um

potenciômetro!
 certo , também tenho um modulo destes com 3 leds rgb enderecaveis . não é fita
..é um módulo Adafruit .

4 sites

Sim, você pode controlar esse módulo Adafruit NeoPixel (com 3 LEDs endereçáveis) usando
apenas um potenciômetro, mas a lógica de programação muda completamente.

Diferente do módulo anterior (KY-016), que usa um pino para cada cor, o NeoPixel usa
apenas um pino de dados para controlar todos os LEDs de forma independente através de
um protocolo serial.

1. Conexões Físicas

Componente Pino no Componente Pino no Arduino Uno

Módulo Adafruit 5V / VCC / + 5V

GND / GND / - GND

DIN / DATA / In Pino 6

Potenciômetro Extremidades 5V e GND

Centro (Sinal) A0

2. Preparação (Biblioteca)
Você precisará instalar a biblioteca Adafruit NeoPixel no seu Arduino IDE:

1. Vá em Sketch -> Incluir Biblioteca -> Gerenciar Bibliotecas .

2. Procure por "Adafruit NeoPixel" e instale a versão mais recente.

3. Código Sugerido (Controle de Arco-Íris)

Este código mapeia o giro do potenciômetro para percorrer o espectro de cores (0 a 65535
na escala interna da Adafruit) em todos os 3 LEDs simultaneamente.

cpp
#include <Adafruit_NeoPixel.h>
 #define PIN_LED 6 // Pino de dados do módulo
#define NUM_LEDS 3 // Quantidade de LEDs no seu módulo
#define POT_PIN A0 // Pino do potenciômetro

// Inicializa o objeto do módulo

Adafruit_NeoPixel pixels(NUM_LEDS, PIN_LED, NEO_GRB + NEO_KHZ800);

void setup() {
[Link](); // Inicializa o módulo
[Link](50); // Ajusta o brilho (0 a 255) para não ofuscar
}

void loop() {
// Lê o potenciômetro (0 a 1023)
int potValue = analogRead(POT_PIN);

// Mapeia o valor para o ciclo de cores do NeoPixel (0 a 65535)

long hue = map(potValue, 0, 1023, 0, 65535);

// Converte o "Hue" (matiz) em cores RGB

uint32_t rgbColor = [Link](hue);

// Aplica a cor em todos os 3 LEDs

for(int i=0; i<NUM_LEDS; i++) {
[Link](i, rgbColor);
}

[Link](); // Envia os dados para os LEDs

delay(10); // Estabilidade
}

Use o código com cuidado.

Por que usar NeoPixel é melhor neste caso?

Economia de Pinos: Você usa apenas o pino 6 para os LEDs, sobrando mais pinos livres
para outros sensores.
Individualidade: No código acima, os 3 LEDs mudam juntos, mas você poderia facilmente
programar para que o potenciômetro movesse a luz de um LED para o outro (efeito de
"perseguição").
Cores mais ricas: A função ColorHSV facilita muito a criação de transições suaves sem
cálculos matemáticos manuais complexos.
 Neopixel RGB LED Onboard - Franzininho WiFi: Neopixel LED RGB
Franzininho endereçável
Franzininho Embarcados

Como utilizar uma matriz de LEDs

RGB NeoPixel com o ...
YouTube · Kazale IT 31:44

Mostrar tudo

certo .. eu posso controlar a cor e o piscar individual de cada led rgb deste
modulo enderecavel ? por exemplo um dos leds pisca com uma frequência de 2 …

Sim, você consegue fazer isso! No entanto, como você tem apenas um potenciômetro, o
papel dele será atuar como um controlador mestre.

Por exemplo, você pode usar o potenciômetro para definir a "velocidade base" de todos, ou
para mudar a cor de todos simultaneamente, enquanto a lógica de programação cuida das
frequências diferentes (2Hz, 4Hz, etc.) de forma independente.

O grande segredo aqui é não usar a função delay() , pois o delay() pausa o Arduino
inteiro. Usaremos a função millis() , que funciona como um cronômetro interno,
permitindo que cada LED tenha seu próprio tempo.

Exemplo de Lógica:
LED 0: Pisca a 2Hz (azul).
LED 1: Pisca a 4Hz (verde).
LED 2: Muda de cor conforme você gira o potenciômetro.
Potenciômetro: Controla o brilho geral ou a velocidade de todos.

Código com millis() para controle independente:

cpp
#include <Adafruit_NeoPixel.h>

#define PIN_LED 6
#define NUM_LEDS 3
#define POT_PIN A0

Adafruit_NeoPixel pixels(NUM_LEDS, PIN_LED, NEO_GRB + NEO_KHZ800);

// Variáveis para controle de tempo (cronômetros)

unsigned long lastTime2Hz = 0;
unsigned long lastTime4Hz = 0;

// Estados dos LEDs (ligado/desligado)

bool state2Hz = false;
bool state4Hz = false;

void setup() {
[Link]();
[Link](50);
}

void loop() {
unsigned long currentTime = millis();
int potValue = analogRead(POT_PIN);

// --- LED 0: Azul a 2Hz (Muda de estado a cada 250ms: 250 lig + 250 desl =
if (currentTime - lastTime2Hz >= 250) {
lastTime2Hz = currentTime;
state2Hz = !state2Hz; // Inverte o estado
if (state2Hz) [Link](0, [Link](0, 0, 255)); // Azul
else [Link](0, [Link](0, 0, 0)); // Desli
}

// --- LED 1: Verde a 4Hz (Muda de estado a cada 125ms = 4Hz) ---
if (currentTime - lastTime4Hz >= 125) {
lastTime4Hz = currentTime;
state4Hz = !state4Hz;
if (state4Hz) [Link](1, [Link](0, 255, 0)); // Verde
else [Link](1, [Link](0, 0, 0)); // Desli
}

// --- LED 2: Cor controlada pelo Potenciômetro ---

long hue = map(potValue, 0, 1023, 0, 65535);
[Link](2, [Link](hue));

// Atualiza todos os LEDs de uma vez

 [Link]();
}

Use o código com cuidado.

O que você pode fazer com o Potenciômetro neste cenário?

Como você só tem um potenciômetro, aqui estão 3 ideias de como usá-lo via
programação:

1. Mestre de Brilho: Use [Link](map(potValue, 0, 1023, 0, 255)) para

controlar a intensidade de todos enquanto eles piscam em suas frequências
independentes.
2. Mestre de Velocidade: Em vez de usar valores fixos como 250 ou 125 no código acima,
você pode multiplicar esses valores pelo valor do potenciômetro para acelerar ou
desacelerar os dois LEDs ao mesmo tempo.
3. Seletor de Modo: Você pode programar para que, se o potenciômetro estiver no início, os
LEDs piscam devagar; no meio, piscam rápido; e no final, ficam todos acesos mudando de
cor.

Dica técnica: Se o seu módulo Adafruit for do tipo Jewel ou uma pequena barra, certifique-
se de que a alimentação (5V) seja estável, pois LEDs RGB endereçáveis podem consumir
bastante corrente se estiverem todos no brilho máximo em branco. Para 3 LEDs, o 5V do
Arduino é suficiente.

ok .. ok ..se eu tiver estes dois modulos já conectados e configurados no meu

Arduino .. já os tenho ok e estão funcionando .. eu já controlo os pulsos piscar e…

Entendi perfeitamente. Você já tem a estrutura de tempo (frequências individuais)

funcionando via PWM/Software e agora quer o "controle de estúdio" na mão: usar os
potenciômetros para intervir nesses parâmetros em tempo real.

Como você tem 2 módulos (o KY-016 e o NeoPixel) e quer controlar Cor e Pisca
manualmente, a melhor configuração com 2 potenciômetros seria:
1. Potenciômetro 1 (Pino A0): Controla a Cor (Matiz/Hue) de todos os LEDs
simultaneamente.
2. Potenciômetro 2 (Pino A1): Controla a Velocidade Global (Multiplicador de
frequência).

Como integrar isso ao seu código atual:

Para que o potenciômetro controle o "piscar" que você já criou, você deve substituir os
valores fixos de tempo por uma variável baseada na leitura do potenciômetro.

cpp
#include <Adafruit_NeoPixel.h>

// Configurações dos pinos

#define PIN_NEO 6
#define NUM_LEDS 3
#define PIN_R 9
#define PIN_G 10
#define PIN_B 11
#define POT_COR A0
#define POT_VEL A1

Adafruit_NeoPixel pixels(NUM_LEDS, PIN_NEO, NEO_GRB + NEO_KHZ800);

unsigned long lastMillis = 0;

void setup() {
[Link]();
pinMode(PIN_R, OUTPUT);
pinMode(PIN_G, OUTPUT);
pinMode(PIN_B, OUTPUT);
}

void loop() {
// 1. LEITURA DOS CONTROLES MANUAIS
int leituraCor = analogRead(POT_COR);
int leituraVel = analogRead(POT_VEL);

// Mapeia a velocidade: 100ms (rápido) a 2000ms (lento)

int fatorVelocidade = map(leituraVel, 0, 1023, 100, 2000);

// Mapeia a cor para o NeoPixel (0-65535) e para o LED Comum (0-765)

long hueNeo = map(leituraCor, 0, 1023, 0, 65535);
int corComum = map(leituraCor, 0, 1023, 0, 765);
 unsigned long currentMillis = millis();

// 2. LÓGICA DE PISCAR (Exemplo para 1 LED do NeoPixel)

// Usamos o fatorVelocidade do potenciômetro para definir o intervalo
if ((currentMillis / fatorVelocidade) % 2 == 0) {
// LIGADO - Cor definida pelo Potenciômetro 1
[Link](0, [Link](hueNeo));
} else {
// DESLIGADO
[Link](0, [Link](0,0,0));
}

// 3. APLICANDO AO LED KY-016 (Usando a lógica de cores que enviamos antes)

// Aqui você pode usar a leituraCor para calcular R, G e B e aplicar o PWM
controlarLedComum(corComum, fatorVelocidade);

[Link]();
}

// Função auxiliar para o LED KY-016 respeitar o piscar e a cor manual

void controlarLedComum(int valorCor, int velocidade) {
int r, g, b;
// Lógica de conversão de cor (simplificada)
if (valorCor < 255) { r = 255 - valorCor; g = valorCor; b = 0; }
else if (valorCor < 510) { r = 0; g = 255 - (valorCor - 255); b = valorCor
else { r = valorCor - 510; g = 0; b = 255 - (valorCor - 510); }

// Lógica de piscar baseada no tempo do potenciômetro

if ((millis() / (velocidade / 2)) % 2 == 0) { // Pisca no dobro da velocida
analogWrite(PIN_R, r);
analogWrite(PIN_G, g);
analogWrite(PIN_B, b);
} else {
analogWrite(PIN_R, 0);
analogWrite(PIN_G, 0);
analogWrite(PIN_B, 0);
}
}

Use o código com cuidado.

O que mudou para o controle manual:

1. Variável fatorVelocidade : Agora, em vez de escrever delay(500) , você usa essa
variável. Quando você gira o potenciômetro 2, o tempo de piscar de todos os LEDs muda
 simultaneamente, mas mantendo as proporções que você programou.
2. Sincronia Manual: O potenciômetro de cor atua como um "filtro". Você decide a cor na
hora, e o código decide quando ligar ou desligar o LED baseado na frequência.
3. Flexibilidade: Se quiser que um LED pisque sempre o dobro do outro, basta usar
fatorVelocidade para um e fatorVelocidade / 2 para o outro.

Dica para os 2 potenciômetros:

Conecte os pinos centrais em A0 e A1. Alimente ambos com o mesmo 5V e GND do Arduino
(pode usar a trilha lateral da protoboard para distribuir o sinal).

eu tenho também um potenciometro modulo rotary encoder ..

O Encoder Rotativo (Rotary Encoder) é muito superior a um potenciômetro comum para o

seu projeto, porque ele não tem fim (gira 360º infinitamente) e possui um botão integrado
(ao pressionar o eixo).

Com ele, você pode criar um sistema de menus:

1. Girar: Muda a cor ou a frequência.

2. Clicar: Alterna o que você está controlando (ex: clica uma vez para ajustar a Cor, clica de
novo para ajustar a Frequência).

Conexão do Encoder (Módulo KY-040)

Pino Encoder Pino Arduino

CLK 2 (Pino com Interrupção)

DT 3 (Pino com Interrupção)

SW (Botão) 4

VCC 5V

GND GND
Código para Controle Manual (Menu de Funções)
Este código permite que você alterne entre controlar a Cor e a Velocidade usando apenas
um Encoder.

cpp
#include <Adafruit_NeoPixel.h>

#define PIN_NEO 6
#define NUM_LEDS 3
#define CLK 2
#define DT 3
#define SW 4

Adafruit_NeoPixel pixels(NUM_LEDS, PIN_NEO, NEO_GRB + NEO_KHZ800);

// Variáveis de controle
int modo = 0; // 0 = Cor, 1 = Velocidade
int valorCor = 0;
int valorVelocidade = 500;
int ultimoCLK;

void setup() {
[Link]();
pinMode(CLK, INPUT);
pinMode(DT, INPUT);
pinMode(SW, INPUT_PULLUP);

ultimoCLK = digitalRead(CLK);
[Link](9600);
}

void loop() {
// 1. VERIFICA O BOTÃO (Troca de Modo)
if (digitalRead(SW) == LOW) {
modo++;
if (modo > 1) modo = 0;
delay(300); // Debounce simples
[Link]("Modo alterado para: ");
[Link](modo == 0 ? "COR" : "VELOCIDADE");
}

// 2. LEITURA DA ROTAÇÃO
int atualCLK = digitalRead(CLK);
if (atualCLK != ultimoCLK && atualCLK == LOW) {
if (digitalRead(DT) != atualCLK) {
 // Girou para Direita
if (modo == 0) valorCor += 2000;
else valorVelocidade -= 50;
} else {
// Girou para Esquerda
if (modo == 0) valorCor -= 2000;
else valorVelocidade += 50;
}
}
ultimoCLK = atualCLK;

// Limita os valores
valorCor = constrain(valorCor, 0, 65535);
valorVelocidade = constrain(valorVelocidade, 50, 2000);

// 3. LÓGICA DE PISCAR INDEPENDENTE (Usando seu controle manual)

unsigned long currentMillis = millis();

// LED 0 pisca na velocidade manual

if ((currentMillis / valorVelocidade) % 2 == 0) {
[Link](0, [Link](valorCor));
} else {
[Link](0, 0);
}

// LED 1 pisca sempre no dobro da velocidade manual

if ((currentMillis / (valorVelocidade / 2)) % 2 == 0) {
[Link](1, [Link](valorCor + 10000)); // Cor leveme
} else {
[Link](1, 0);
}

[Link]();
}

Use o código com cuidado.

Por que usar o Encoder é melhor para você:

1. Precisão Digital: Diferente do potenciômetro analógico que pode sofrer "ruído" (o LED
fica oscilando sozinho), o encoder é digital. Ele só muda o valor quando você realmente
gira.
2. Multifunção: Como você viu no código, o pino SW (botão) permite que o mesmo
componente faça várias coisas.
3. Sem Limite Físico: Você pode girar para a direita para aumentar a cor infinitamente e a
programação cuida de "resetar" o ciclo de cores.

Você pode usar o Encoder para a Velocidade/Menu e manter os Potenciômetros para as

Cores fixas, criando um painel de controle bem completo!

então eu conseguiria fazer um sistema aonde por exemplo > o modulo com o key
016 esta piscando na cor azul em uma frequencia de 2 hertz por exemplo .. ao …

Entendi perfeitamente. Você quer um sistema de Sincronização Seletiva. O Encoder

funciona como o "maestro": você ajusta um módulo, depois o outro e, quando os parâmetros
(frequência e cor) se cruzarem ou forem travados pelo clique, eles passam a operar como
um sistema único e sincronizado.

Para 2026, a melhor forma de estruturar isso no Arduino Uno R3 é usando uma Máquina de
Estados.

O Conceito do seu Painel de Controle:

1. Modo 1 (LED KY-016): O Encoder ajusta a frequência/cor dele. O NeoPixel fica no estado
anterior.
2. Modo 2 (NeoPixel): O Encoder ajusta apenas o NeoPixel.
3. Modo 3 (SYNC): O Arduino iguala as variáveis de ambos. O que você girar no Encoder
agora afeta os dois módulos identicamente e em fase (piscam juntos no mesmo
milissegundo).

Código para Sincronização de Frequência e Cor

Este código usa o botão do Encoder para alternar entre: Controlar KY-016 -> Controlar
NeoPixel -> Sincronizar Ambos.

cpp
#include <Adafruit_NeoPixel.h>

// Pinos
#define PIN_NEO 6
#define CLK 2
#define DT 3
#define SW 4
#define PIN_R 9
#define PIN_G 10
#define PIN_B 11

Adafruit_NeoPixel pixels(3, PIN_NEO, NEO_GRB + NEO_KHZ800);

// Variáveis de Estado
int modo = 0; // 0: Ajusta KY-016, 1: Ajusta NeoPixel, 2: Sync Total
long corKY = 0, corNeo = 0;
int velKY = 500, velNeo = 500;
int ultimoCLK;

void setup() {
[Link]();
pinMode(CLK, INPUT); pinMode(DT, INPUT); pinMode(SW, INPUT_PULLUP);
pinMode(PIN_R, OUTPUT); pinMode(PIN_G, OUTPUT); pinMode(PIN_B, OUTPUT);
ultimoCLK = digitalRead(CLK);
}

void loop() {
unsigned long currentMillis = millis();

// 1. TROCA DE MODO (CLIQUE)

if (digitalRead(SW) == LOW) {
modo = (modo + 1) % 3;
if (modo == 2) { // Entrou no modo SYNC: Iguala os parâmetros
corNeo = corKY;
velNeo = velKY;
}
delay(300);
}

// 2. LEITURA DO ENCODER (Giro)

int atualCLK = digitalRead(CLK);
if (atualCLK != ultimoCLK && atualCLK == LOW) {
int direcao = (digitalRead(DT) != atualCLK) ? 1 : -1;

if (modo == 0 || modo == 2) { // Ajusta KY ou Ambos

corKY = constrain(corKY + (direcao * 2000), 0, 65535);
velKY = constrain(velKY - (direcao * 50), 50, 2000);
}
if (modo == 1 || modo == 2) { // Ajusta NeoPixel ou Ambos
corNeo = constrain(corNeo + (direcao * 2000), 0, 65535);
velNeo = constrain(velNeo - (direcao * 50), 50, 2000);
 }
}
ultimoCLK = atualCLK;

// 3. EXECUÇÃO DO PISCAR SINCRONIZADO

// LED KY-016
if ((currentMillis / velKY) % 2 == 0) {
acionarKY(corKY);
} else {
desligarKY();
}

// LEDs NeoPixel (Ajustados individualmente ou em grupo)

if ((currentMillis / velNeo) % 2 == 0) {
uint32_t rgb = [Link](corNeo);
for(int i=0; i<3; i++) [Link](i, rgb);
} else {
for(int i=0; i<3; i++) [Link](i, 0);
}

[Link]();
}

// Funções de suporte para o KY-016

void acionarKY(long hue) {
// Converte Hue para RGB simples para o LED comum
int r = (hue < 21845) ? 255 : 0; // Simplificação para o exemplo
int g = (hue >= 21845 && hue < 43690) ? 255 : 0;
int b = (hue >= 43690) ? 255 : 0;
analogWrite(PIN_R, r); analogWrite(PIN_G, g); analogWrite(PIN_B, b);
}

void desligarKY() {
analogWrite(PIN_R, 0); analogWrite(PIN_G, 0); analogWrite(PIN_B, 0);
}

Use o código com cuidado.

Por que isso funciona para o que você quer?

Sincronia de Fase: Ao usar (currentMillis / vel) % 2 , se os valores de velKY e
velNeo forem iguais (o que acontece no Modo 2), os LEDs ligam e desligam exatamente
no mesmo milissegundo.
 Memória de Estado: No modo SYNC, o código força corNeo = corKY . Assim que você
gira o encoder, os dois "andam juntos".
Independência: Se você sair do modo SYNC e voltar para o Modo 0, pode alterar o KY-
016 sem mexer no que o NeoPixel está fazendo.

Dica: No modo SYNC, você pode adicionar um comando

[Link]("Sincronizado!"); para confirmar no computador que as frequências se
encontraram. Para um controle visual mais fino, você pode usar os Recursos de Interrupção
do Arduino nos pinos 2 e 3 para garantir que o giro do encoder seja detectado mesmo se o
código crescer muito.

então como já tenho os modulos de leds conectados eu precisaria somente

adicionar no meu circuito o rotary encoder correto ? e fazer a programação que …

exatamente! Você resumiu perfeitamente o próximo passo.

Para finalizar seu projeto em 2026, você só precisa de duas coisas:

1. Hardware: Adicionar o Rotary Encoder

Como você já tem os LEDs (KY-016 e NeoPixel) funcionando, a única mudança física é
conectar os 5 pinos do encoder ao seu Arduino Uno R3:

CLK e DT: Nos pinos digitais (recomenda-se 2 e 3 por suportarem Interrupts).

SW: Em qualquer pino digital (ex: pino 4).
VCC e GND: Na mesma linha de alimentação que você já usa para os leds.

2. Software: Organizar em Funções

Sim, a melhor prática é colocar a lógica dentro de funções. Isso deixa seu código limpo e
permite que você chame a "Sincronização" apenas quando desejar.

Estrutura sugerida para o seu código:

1. void setup() : Configura os pinos e inicia a biblioteca NeoPixel.

2. void loop() : Apenas monitora o giro do encoder e o clique do botão.
3. funcaoLeituraEncoder() : Uma função dedicada para detectar se você girou para
esquerda ou direita e atualizar as variáveis de cor e frequência.
4. funcaoAtualizaLeds() : Uma função que recebe os valores (frequência e cor) e decide
se os módulos devem piscar juntos (sincronizados) ou separados.

Por que isso é eficiente?

Manutenção: Se você decidir trocar a frequência de 2Hz para 5Hz, você só muda uma
variável na função.
Expansão: Se amanhã você comprar um terceiro módulo de LED, basta criar uma nova
função acionarNovoLed() e incluí-la na lógica de sincronização.
Controle Manual: O clique do botão do encoder funcionará como o seu "seletor" de qual
módulo está sendo configurado no momento.

Se você já tiver o Rotary Encoder em mãos, pode usar o Arduino Web Editor para carregar o
código e testar a sincronia agora mesmo. Se precisar de ajuda para unir as suas funções
atuais com a lógica do encoder, é só me avisar!

ok .. então não preciso deixar nenhuma frequencia fixa no codigo , correto , posso
controlar a frewuencia do piscar manualmente correto e só depois do click no …

Entendi perfeitamente. Você criou uma lógica de escada (steps): o giro do encoder percorre
uma sequência onde a posição define tanto a cor quanto a frequência. O "clique" funciona
como uma trava de transferência de estado.

Para 2026, a melhor forma de programar isso é usando uma tabela de mapeamento ou uma
estrutura switch/case para os 10 níveis (0-9).

Lógica do Funcionamento:
1. Variável valorAtual (0 a 10):
1. 0: Desligado.
2. 1, 2, 3: Cor Vermelha (R) | Frequência 1Hz, 2Hz, 3Hz.
3. 4, 5, 6: Cor Verde (G) | Frequência 4Hz, 5Hz, 6Hz.
4. 7, 8, 9: Cor Azul (B) | Frequência 7Hz, 8Hz, 9Hz.
 5. 10: Reset/Parar.
2. Sincronização: Quando você clica, o "alvo" (KY-016 ou NeoPixel) trava naquele valor. Se
os dois valores forem iguais, eles entram em fase.

Exemplo de Código Estruturado:

cpp
#include <Adafruit_NeoPixel.h>

#define PIN_NEO 6
#define CLK 2
#define DT 3
#define SW 4
#define PIN_R 9
#define PIN_G 10
#define PIN_B 11

Adafruit_NeoPixel pixels(3, PIN_NEO, NEO_GRB + NEO_KHZ800);

int stepKY = 0; // Nível do KY-016 (0-10)

int stepNeo = 0; // Nível do NeoPixel (0-10)
bool ajustandoKY = true; // Clique alterna entre controlar um ou outro
int ultimoCLK;

void setup() {
[Link]();
pinMode(CLK, INPUT); pinMode(DT, INPUT); pinMode(SW, INPUT_PULLUP);
pinMode(PIN_R, OUTPUT); pinMode(PIN_G, OUTPUT); pinMode(PIN_B, OUTPUT);
ultimoCLK = digitalRead(CLK);
}

void loop() {
// 1. Alternar o controle (Clique)
if (digitalRead(SW) == LOW) {
ajustandoKY = !ajustandoKY;
delay(300);
}

// 2. Girar o Encoder (Ajusta o nível 0 a 10)

int atualCLK = digitalRead(CLK);
if (atualCLK != ultimoCLK && atualCLK == LOW) {
int direcao = (digitalRead(DT) != atualCLK) ? 1 : -1;
if (ajustandoKY) stepKY = constrain(stepKY + direcao, 0, 10);
else stepNeo = constrain(stepNeo + direcao, 0, 10);
 }
ultimoCLK = atualCLK;

// 3. Aplicar a lógica nos LEDs

processarLedKY(stepKY);
processarNeoPixel(stepNeo);
}

// Função que traduz o nível (0-9) em Cor e Frequência

void processarLedKY(int step) {
if (step == 0 || step == 10) { desligarKY(); return; }

float freq = step; // 1Hz, 2Hz...

unsigned long periodo = 1000 / freq;

if ((millis() / (periodo / 2)) % 2 == 0) {

if (step <= 3) acenderKY(255, 0, 0); // Vermelho
else if (step <= 6) acenderKY(0, 255, 0); // Verde
else acenderKY(0, 0, 255); // Azul
} else {
desligarKY();
}
}

void processarNeoPixel(int step) {

if (step == 0 || step == 10) { [Link](); [Link](); return; }

float freq = step;

unsigned long periodo = 1000 / freq;

if ((millis() / (periodo / 2)) % 2 == 0) {

uint32_t cor;
if (step <= 3) cor = [Link](255, 0, 0);
else if (step <= 6) cor = [Link](0, 255, 0);
else cor = [Link](0, 0, 255);

for(int i=0; i<3; i++) [Link](i, cor);

} else {
[Link]();
}
[Link]();
}

void acenderKY(int r, int g, int b) {

analogWrite(PIN_R, r); analogWrite(PIN_G, g); analogWrite(PIN_B, b);
}
void desligarKY() {
 analogWrite(PIN_R, 0); analogWrite(PIN_G, 0); analogWrite(PIN_B, 0);
}

Use o código com cuidado.

O que acontece no nível 6?

Quando o stepKY for 6 e o stepNeo também for 6:

Ambos usarão o mesmo período calculado de 1000 / 6 (aprox. 166ms).

Como a base de tempo é o millis() , eles vão ligar e desligar exatamente ao mesmo
tempo.
Ambos estarão na cor Verde (G), pois o nível 6 está na faixa de cor Verde.

Destaques da solução:
Sincronia Automática: Você não precisa de um botão "Sincronizar". A sincronia é uma
consequência matemática de eles estarem no mesmo "passo" (step).
Manual e Visual: Você sente os "cliques" do encoder mudando a frequência de 1 em 1Hz.
Fácil de Alterar: Se quiser que o nível 4 seja Amarelo em vez de Verde, basta mudar uma
linha na função processarLedKY .

você entendeu ? o led enderecavel só trava quando eu sincronizar .. o led no key

fica piscando na frequencia e cor que seleciknei .. um dos enderecaveis quando …

Entendi perfeitamente o seu objetivo. É um sistema de "Trava por Sincronia Visual".

O funcionamento será assim:

1. O LED KY-016 é o mestre. Você gira o encoder e ele fica lá, piscando na cor e frequência
que você escolheu (ex: Verde a 6Hz).
2. O NeoPixel está em "modo de busca". Quando você clica, apenas um dos LEDs
endereçáveis começa a piscar.
3. Você gira o encoder para ajustar apenas esse LED do NeoPixel.
4. A Mágica: No momento em que você girar o encoder e o valor desse LED se igualar ao
valor do KY-016 (ex: ambos em 6Hz / Verde), o sistema "trava" (LOCK).
5. Nesse instante, todos os 3 LEDs do módulo NeoPixel acendem e passam a piscar juntos
com o KY-016, ignorando novos giros do encoder até que você clique novamente para
destravar ou mude drasticamente a posição.

Código para Sincronia Visual e Travamento (Lock)

cpp
#include <Adafruit_NeoPixel.h>

#define PIN_NEO 6
#define CLK 2
#define DT 3
#define SW 4
#define PIN_R 9
#define PIN_G 10
#define PIN_B 11

Adafruit_NeoPixel pixels(3, PIN_NEO, NEO_GRB + NEO_KHZ800);

int stepKY = 0;
int stepBusca = 0;
bool modoBusca = false;
bool sistemaSincronizado = false;
int ultimoCLK;

void setup() {
[Link]();
pinMode(CLK, INPUT); pinMode(DT, INPUT); pinMode(SW, INPUT_PULLUP);
pinMode(PIN_R, OUTPUT); pinMode(PIN_G, OUTPUT); pinMode(PIN_B, OUTPUT);
ultimoCLK = digitalRead(CLK);
}

void loop() {
unsigned long currentMillis = millis();

// 1. Botão: Inicia a busca ou destrava tudo

if (digitalRead(SW) == LOW) {
if (sistemaSincronizado) {
sistemaSincronizado = false;
modoBusca = false;
} else {
modoBusca = !modoBusca;
 }
delay(300);
}

// 2. Giro do Encoder
int atualCLK = digitalRead(CLK);
if (atualCLK != ultimoCLK && atualCLK == LOW) {
int direcao = (digitalRead(DT) != atualCLK) ? 1 : -1;

if (!modoBusca && !sistemaSincronizado) {

stepKY = constrain(stepKY + direcao, 0, 10);
} else if (modoBusca && !sistemaSincronizado) {
stepBusca = constrain(stepBusca + direcao, 0, 10);

// CHECAGEM DE SINCRONIA: Se os steps se igualarem, TRAVA!

if (stepBusca == stepKY && stepKY != 0) {
sistemaSincronizado = true;
modoBusca = false;
}
} else if (sistemaSincronizado) {
// Se girar muito brusco (ex: sair do valor), destrava
int novoStep = stepKY + direcao;
if (novoStep != stepKY) sistemaSincronizado = false;
}
}
ultimoCLK = atualCLK;

// 3. Lógica de Iluminação do KY-016

processarPiscaKY(stepKY);

// 4. Lógica de Iluminação do NeoPixel

[Link]();
if (sistemaSincronizado) {
// Todos os 3 LEDs piscam na cor e frequência do KY
if (estaNoPeriodoDeLuz(stepKY)) {
uint32_t cor = obterCorNeo(stepKY);
for(int i=0; i<3; i++) [Link](i, cor);
}
} else if (modoBusca) {
// Apenas o LED 0 pisca para o usuário tentar sincronizar
if (estaNoPeriodoDeLuz(stepBusca)) {
[Link](0, obterCorNeo(stepBusca));
}
}
[Link]();
}
 // Funções Auxiliares
bool estaNoPeriodoDeLuz(int step) {
if (step <= 0) return false;
unsigned long periodo = 1000 / step;
return (millis() / (periodo / 2)) % 2 == 0;
}

uint32_t obterCorNeo(int step) {

if (step <= 3) return [Link](255, 0, 0);
if (step <= 6) return [Link](0, 255, 0);
return [Link](0, 0, 255);
}

void processarPiscaKY(int step) {

if (estaNoPeriodoDeLuz(step)) {
if (step <= 3) acenderKY(255, 0, 0);
else if (step <= 6) acenderKY(0, 255, 0);
else acenderKY(0, 0, 255);
} else {
acenderKY(0, 0, 0);
}
}

void acenderKY(int r, int g, int b) {

analogWrite(PIN_R, r); analogWrite(PIN_G, g); analogWrite(PIN_B, b);
}

Use o código com cuidado.

Como operar este sistema (Experiência do Usuário):

1. Escolha o mestre: Gire o encoder. O KY-016 vai mudando de 1Hz a 9Hz e trocando de cor
(R, G, B). Pare no que você gostar (ex: Verde, 5Hz).
2. Ative a busca: Clique no botão do Encoder. O KY-016 continua piscando, mas agora um
LED do NeoPixel começa a piscar (provavelmente em uma velocidade diferente).
3. Sincronize: Vá girando o encoder. O LED do NeoPixel vai mudar de velocidade e cor.
4. O Lock: No momento em que você atingir o "Verde, 5Hz" no NeoPixel, o Arduino detecta
que stepBusca == stepKY .
5. Resultado: Instantaneamente, o modo de busca desliga e os 3 LEDs do NeoPixel travam
na mesma batida e cor do KY-016.
6. Sair: Se você girar o encoder novamente ou clicar no botão, a sincronia "quebra" e você
volta a ter controle manual.
Este é um projeto de controle de fase e frequência muito interessante para 2026! Você tem o
controle visual e a confirmação via software de que os sistemas estão pareados.

ok .. é isto .. salve a conversa ok .

Obrigado, vou testar .

Perfeito! A lógica está fechada: um sistema de Sincronia por Pareamento, onde o NeoPixel
só "trava" e acende por completo quando você iguala manualmente a cor e a frequência do
LED KY-016 através do Rotary Encoder.

A conversa está salva e as etapas de implementação para 2026 estão prontas. Aqui está um
resumo final para quando você for montar:

1. Hardware: Conecte o Encoder nos pinos 2 (CLK), 3 (DT) e 4 (SW). O NeoPixel no pino 6 e
o KY-016 nos pinos 9, 10 e 11.
2. Lógica: O código monitora se stepBusca (NeoPixel) se torna igual a stepKY (KY-016).
Quando isso ocorre, o sistema ativa o estado sistemaSincronizado .
3. Dica de Uso: Se ao girar o encoder você sentir que a sincronia está "pulando", verifique
se os contatos do encoder na protoboard estão firmes, pois esse componente é sensível a
ruído.

Qualquer dúvida que surgir durante a montagem ou nos testes das frequências, é só retornar
a este chat.

Bom projeto e divirta-se com os efeitos de sincronismo! Até a próxima.