Este artigo irá guiá-lo pelos conceitos básicos de utilização de um LED RGB com Arduino, para que possa criar as suas próprias cores com a ajuda de potenciômetros.
Vou mostrar-lhe diagramas de ligação passo a passo e explicar o código para que compreenda completamente como usar este componente.
Após este tutorial, deverá ter um circuito que ilumina numa cor à sua escolha usando valores RGB, controlados por potenciômetros e mostrados no Monitor Serial.
Materiais
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Hardware
- x1 Arduino Uno Rev3 (Amazon)
- x1 LED RGB, cátodo comum (Amazon)
- x3 Resistores de 220 Ohm (Amazon)
- x3 Potenciômetros de 10k Ohm (Amazon)
- x1 Breadboard (Amazon)
- x~17 Fios jumper (Amazon)
- x1 Cabo USB B (Amazon)
Software
- Arduino IDE
Também pode encontrar LEDs RGB em KY-016 módulos, que têm o LED e os resistores necessários numa única PCB.
Estes módulos não permitem flexibilidade na construção do circuito, mas são mais plug-and-play do que as alternativas.
Não os recomendaria, prefiro a flexibilidade de usar resistores, e algumas análises mostram reprodução de cor pobre ao usar valores RGB.
Instruções
Passo 1 – Ligar o LED RGB
Este diagrama de ligação mostra como conectar um LED RGB à placa Arduino.
Note que este é um LED de cátodo comum, em que o pino mais longo está ligado ao terra; mais à frente explicarei o que significa cátodo comum.
As ligações estão também indicadas na tabela abaixo.
| Componente | Pino Arduino |
| LED – Vermelho | 11 |
| LED – Cátodo | GND |
| LED – Verde | 10 |
| LED – Azul | 9 |
Certifique-se de incluir um resistor de 220Ω entre os pinos vermelho, verde e azul do LED e as saídas para evitar danos ao LED e ao Arduino.
Noções básicas sobre LED RGB
Um LED RGB pode ser visto como três LEDs — um vermelho, um verde e um azul — num único pacote; este LED único brilha na combinação das intensidades vermelha, verde e azul.
Os LEDs RGB parecem LEDs normais com quatro pinos, sendo o mais longo o pino comum.
LEDs RGB de Cátodo Comum e Ânodo Comum
Mencionei anteriormente LEDs de cátodo comum e ânodo comum. Os LEDs RGB existem em dois tipos: cátodo comum e ânodo comum.
Nos LEDs de cátodo comum, o pino mais longo liga-se ao GND e os seus componentes acendem com um sinal de 5V; nos LEDs de ânodo comum é o contrário: o pino mais longo vai a 5V, e um sinal de 0V liga os componentes.
Neste exemplo, usaremos LEDs de cátodo comum; se tiver um LED RGB de ânodo comum, a ligação e as saídas terão de ser invertidas.
A única forma de saber se o seu RGB é cátodo comum ou ânodo comum é testando o LED; recomendo testar com um multímetro usando a função de diodo.
Para testar, coloque a sonda negativa no pino comum e a sonda positiva em qualquer outro pino; se o LED acender, é cátodo comum.
Se não acender, coloque a sonda positiva no pino comum e a negativa em qualquer outro pino; o LED deve acender, indicando que é ânodo comum.
Se não tiver um multímetro, pode fazer isto com os pinos 5V e GND do Arduino, apenas certifique-se de ter um resistor de 220Ω no circuito.
Controlar o Brilho do LED com PWM
O brilho de um LED é controlado pela corrente que passa por ele, mas não podemos controlar diretamente a corrente porque o Arduino Uno não tem saídas totalmente analógicas; para controlar o brilho usaremos Modulação por Largura de Pulso (PWM).
O PWM liga e desliga a saída periodicamente, e o tempo que a saída permanece ligada determina o brilho do LED.
O PWM liga e desliga a saída periodicamente, e o tempo que a saída permanece ligada determina o brilho do LED.
A intensidade do LED é determinada pelo ciclo de trabalho do PWM, que é o tempo que a saída fica ligada. Um ciclo de trabalho de 50% significa que a saída está alta 50% do tempo e baixa os outros 50%.
Este ciclo ocorre a 490 Hz, 490 vezes por segundo, e pode controlar este ciclo de trabalho com AnalogWrite.
O PWM liga e desliga a saída periodicamente, e o tempo que a saída permanece ligada determina o brilho do LED.
Passo 2 – Ligar os Três Potenciômetros
Neste passo, precisa de ligar três potenciômetros a 5V, GND e aos pinos analógicos A0, A1 e A2.
As pernas exteriores ligam-se a 5V e GND, a perna do meio liga-se aos pinos analógicos conforme esta figura:
Em forma de tabela:
| Componente | Pino Arduino |
| Pino mais à direita (qualquer) | 5V |
| Pino mais à esquerda (qualquer) | GND |
| Pino do meio (vermelho) | A0 |
| Pino do meio (verde) | A1 |
| Pino do meio (azul) | A2 |
Usar um Potenciômetro como Entrada Analógica
Para controlar os valores do LED RGB, usará as saídas dos potenciômetros (pino do meio) como entradas analógicas.
O Arduino Uno tem 6 entradas analógicas, rotuladas de A0 a A5; estas envolvem um Conversor Analógico-Digital (ADC) de 10 bits com 6 canais.
Este conversor analógico-digital retorna um número de 0 a 1023 (1024 bits = 2¹⁰ = 10 bits), dependendo da tensão que lê num canal.
Vamos alterar o ciclo de trabalho do PWM dos componentes do LED conforme este valor.
Pode considerar um potenciômetro neste circuito como um divisor de tensão: ao rodar o botão, a resistência do pino do meio muda, e a tensão também.
Isto “divide” a entrada de 5V em duas partes se medir a tensão entre a saída e 5V, e entre a saída e GND.
Passo 3: Código de Exemplo Arduino RGB LCD
Agora que a ligação está feita, só falta ligar o Arduino ao seu PC e carregar o sketch.
Pode carregar o código seguinte através do Arduino IDE, pode copiar o código clicando no botão no canto superior direito do campo de código.
/*Example sketch to control an RGB LED with Arduino using potentiometers
More info: https://www.makerguides.com */
//Definition of pins: outputs
#define redPin 11
#define greenPin 10
#define bluePin 9
//Definition of pins: analog inputs
#define redPot A0
#define greenPot A1
#define bluePot A2
int redVal, greenVal, blueVal; // RGB component values
void setup() {
//Pin definitions
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(redPot, INPUT);
pinMode(greenPot, INPUT);
pinMode(bluePot, INPUT);
Serial.begin(9600);
}
void loop() {
//Reading potentiometer values
//When the pot is in the leftmost position, the voltage reading is 0
redVal = analogRead(redPot)/4;
greenVal = analogRead(greenPot)/4;
blueVal = analogRead(bluePot)/4;
//Sets the individual colors with the pot values
analogWrite(redPin, redVal);
analogWrite(greenPin, greenVal);
analogWrite(bluePin, blueVal);
delay(50);
//Printing the values of Red, Green and Blue in a single line
Serial.print("R: "); Serial.print(redVal);
//The \t character creates a tab space between colors
Serial.print("\tG: "); Serial.print(greenVal);
//Final value is Serial.println to create a new line between readings
Serial.print("\tB: "); Serial.println(blueVal);
}
Como o Código Funciona
O primeiro passo é definir os pinos relevantes, feito através da instrução #define que substitui a palavra-chave definida pelo valor desejado quando o programa é compilado.
Com isto definimos as saídas do LED vermelho, verde e azul como os pinos 11, 10 e 9 respetivamente.
Depois fazemos o mesmo procedimento com as entradas dos potenciômetros, usando os pinos analógicos A0, A1 e A2.
Também defini três variáveis globais, uma para cada pino RGB. Estes valores são definidos como inteiros, que deve usar sempre que trabalhar com números inteiros.
O valor de um inteiro pode variar entre -2.147.483.648 e 2.147.483.647. Se quiser ser mais eficiente com a memória do Arduino pode usar o tipo de dados byte , que varia de 0 a 255.
Isto não é necessário neste exemplo simples, mas é útil ter em mente em sketches mais complexos.
//Definition of pins: outputs #define redPin 11 #define greenPin 10 #define bluePin 9 int redVal, greenVal, blueVal; //RGB component values
Na função setup() do sketch definimos os pinos do LED como Outputs, e os pinos dos potenciômetros como inputs usando a função pinMode().
Depois iniciamos o buffer Serial a 9600 baud com Serial.begin(9600); com esta função poderá ler os valores de cor que imprime numa secção posterior do sketch.
void setup() {
//Pin definitions
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(redPot, INPUT);
pinMode(greenPot, INPUT);
pinMode(bluePot, INPUT);
Serial.begin(9600);
Agora passamos para a função loop(). Primeiro, começamos por ler os valores dos potenciômetros.
Isto é feito usando a função analogRead(), onde especifica o pino e esta retorna um valor entre 0 e 1024, como mencionado anteriormente.
Infelizmente, para controlar os LEDs com a função analogWrite() precisamos de valores entre 0 e 255; para isso dividimos o valor lido por 4 e atribuímos às nossas variáveis inteiras.
//Reading potentiometer values //When the pot is in the leftmost position, the voltage reading is 0V redVal = analogRead(redPot)/4; greenVal = analogRead(greenPot)/4; blueVal = analogRead(bluePot)/4;
Neste passo uso as saídas PWM do Arduino para acender os pinos vermelho, verde e azul do LED RGB com os valores inteiros obtidos dos potenciômetros; só precisa especificar o pino e o número entre 0 e 255.
//Sets the individual colors with the pot values analogWrite(redPin, redVal); analogWrite(greenPin, greenVal); analogWrite(bluePin, blueVal);
De seguida introduzo um pequeno atraso no código, faço isto para evitar que o monitor serial role demasiado rápido, mantendo o LED RGB responsivo às entradas.
Este atraso dura 50 milissegundos: 50 milésimos de segundo ou 0,05 segundos.
Pode ajustar este atraso como quiser, apenas note que um atraso muito grande fará com que os valores RGB atualizem mais lentamente.
delay(50);
Finalmente, para verificar quais os valores RGB mostrados no LED, vamos imprimi-los no monitor serial.
Para maior clareza, estes serão impressos numa única linha. Para isso usaremos a função Serial.print().
Aqui imprimo a letra correspondente a cada componente do LED RGB e o seu valor escrito. Usei o caractere de escape \t para criar um espaçamento de tabulação entre cada cor, escape characters seguido de uma barra invertida, que não aparece na string impressa, pois executa funções especiais.
Além disso, a última função serial é Serial.println(), que garante que a próxima mensagem serial aparece numa nova linha.
Serial.print("R: "); Serial.print(redVal);
Serial.print("\\tG: "); Serial.print(greenVal);
Serial.print("\\tB: "); Serial.println(blueVal);
Para ver as mensagens no monitor serial, pressione Ctrl+Shift+M no Arduino IDE, ou clique no ícone da lupa. Certifique-se de que a taxa de baud está definida para 9600 para ler corretamente as mensagens.
Deverá ver algo semelhante à imagem seguinte:
É isso! Se seguiu os passos corretamente, deverá conseguir controlar o LED RGB e produzir todo o tipo de cores usando os potenciômetros.
Cor Aditiva
A propriedade das luzes de cores diferentes se combinarem para criar uma nova cor chama-se cor aditiva.
Esta propriedade permite que os ecrãs mostrem cerca de 16 milhões de tons de cor: definindo as luzes vermelha, verde e azul para um valor de 0 a 255, tal como no nosso projeto.
Pode experimentar algumas das combinações básicas mostradas na imagem abaixo, ou ir a um color picker e criar a sua própria!
Os resultados podem variar: alguns componentes nos LEDs RGB são mais fortes que outros e podem precisar de ajuste.
Conclusão
Neste artigo, mostrei-lhe como usar um LED RGB com Arduino: a sua ligação, as saídas analógicas necessárias, e um circuito simples que mostra como personalizar facilmente a cor do LED.
Se tiver dúvidas ou sugestões para este tutorial, deixe um comentário abaixo.
Adoraria ajudar!
