Un LED RGB es un tipo de LED que puede emitir luz de distintos colores. Esto se logra mediante la combinación de tres colores básicos: rojo, verde y azul. Cada uno de estos colores se controla por una patilla o pin del LED.

Para usar un LED RGB con una placa Arduino UNO, necesitarás tener los siguientes materiales:

• Una placa Arduino UNO
• Un LED RGB
• Tres resistencias de 220 ohmios (una para cada pin del LED)
• Cuatro cables jumper

El primer paso será conectar las patillas o pines del LED RGB a la placa Arduino. Cada pin se conectará a uno de los pines digitales de la placa Arduino a través de una resistencia de 220 ohmios. Por ejemplo, podrías conectar el pin rojo del LED al pin digital 9 de la placa Arduino, el pin verde al pin digital 10 y el pin azul al pin digital 11. Asegúrate de conectar la patilla negativa o común del LED al GND de la placa.

Una vez que hayas conectado el LED, puedes escribir el código en Arduino para controlar el color del LED. En el código, debes especificar qué pin se utilizará para controlar cada color. Por ejemplo, para encender el LED rojo, debes poner el pin 9 en alto (HIGH) y los otros dos pines en bajo (LOW).

A continuación te presentamos un ejemplo de código en Arduino para encender el LED RGB en distintos colores:

const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  // Inicializamos los pines digitales como salidas
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Encendemos el LED rojo
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, LOW);
  delay(1000);

  // Encendemos el LED verde
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, LOW);
  delay(1000);

  // Encendemos el LED azul
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, HIGH);
  delay(1000);

  // Encendemos el LED en amarillo (rojo + verde)
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, LOW);
  delay(1000);

  // Encendemos el LED en magenta (rojo + azul)
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, HIGH);

Regular la intensidad de los colores

se puede usar la técnica de modulación por ancho de pulso (PWM) para controlar la intensidad de cada color del LED RGB. Con PWM, puedes controlar el porcentaje de tiempo que cada pin del LED está en alto y, de esta manera, ajustar la intensidad de cada color.

Para usar PWM con el LED RGB, debes utilizar las funciones analogWrite() en lugar de digitalWrite(). Esta función toma dos argumentos: el número del pin al que quieres enviar el pulso y un valor

entero entre 0 y 255 que indica la intensidad del pulso. Por ejemplo, si quieres enviar un pulso del 50% de intensidad al pin 9, debes utilizar el siguiente código:

analogWrite(9, 128);

A continuación te presentamos un ejemplo de código en Arduino para controlar la intensidad de cada color del LED RGB mediante PWM:

const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  // Inicializamos los pines digitales como salidas
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Ajustamos la intensidad de cada color
  analogWrite(redPin, 255);   // Rojo al máximo
  analogWrite(greenPin, 128); // Verde al 50%
  analogWrite(bluePin, 0);    // Azul apagado
  delay(1000);
}

Con esto podrás controlar la intensidad de cada color del LED RGB y, de esta manera, obtener una amplia gama de colores y tonos.

A continuación te presentamos un ejemplo de código en Arduino para generar distintos colores mediante la intensidad de cada color:

const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  // Inicializamos los pines digitales como salidas
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Generamos el color rojo
  analogWrite(redPin, 255);   // Rojo al máximo
  analogWrite(greenPin, 0);   // Verde apagado
  analogWrite(bluePin, 0);    // Azul apagado
  delay(1000);

  // Generamos el color verde
  analogWrite(redPin, 0);     // Rojo apagado
  analogWrite(greenPin, 255); // Verde al máximo
  analogWrite(bluePin, 0);    // Azul apagado
  delay(1000);

  // Generamos el color azul
  analogWrite(redPin, 0);     // Rojo apagado
  analogWrite(greenPin, 0);   // Verde apagado
  analogWrite(bluePin, 255);  // Azul al máximo
  delay(1000);

  // Generamos el color amarillo (rojo + verde)
  analogWrite(redPin, 255);   // Rojo al máximo
  analogWrite(greenPin, 255); // Verde al máximo
  analogWrite(bluePin, 0);    // Azul apagado
  delay(1000);

  // Generamos el color magenta (rojo + azul)
  analogWrite(redPin, 255);   // Rojo al máximo
  analogWrite(greenPin, 0);   // Verde apagado
  analogWrite(bluePin, 255);  // Azul al máximo
  delay(1000);

  // Generamos el color cyan (verde + azul)
  analogWrite(redPin, 0);     // Rojo apagado
  analogWrite(greenPin, 255); // Verde al máximo
  analogWrite(bluePin, 255);  // Azul al máximo
  delay(1000);

  // Generamos el color blanco (rojo + verde + azul al máximo)
  analogWrite(redPin, 255);   // Rojo al máximo
  analogWrite(greenPin, 255); // Verde al máximo
  analogWrite(bluePin, 255);  // Azul al máximo
  delay(1000);
}

LED de ánodo y de cátodo común

Un LED RGB con cátodo común es un tipo de LED en el que todas las patillas o pines de los colores rojo, verde y azul están conectadas a una misma patilla o pin común, que se conoce como cátodo. Esta patilla suele ser la patilla más larga del LED y se conecta al GND o a un voltaje negativo.

Por otro lado, un LED RGB con ánodo común es un tipo de LED en el que todas las patillas o pines de los colores rojo, verde y azul están conectadas a una misma patilla o pin común, que se conoce como ánodo. Esta patilla suele ser la patilla más corta del LED y se conecta a un voltaje positivo.

La principal diferencia entre estos dos tipos de LED RGB es el polo al que se conectan las patillas de los colores. En el caso del LED RGB con cátodo común, las patillas de los colores se conectan al GND o a un voltaje negativo, mientras que en el caso del LED RGB con ánodo común, las patillas de los colores se conectan a un voltaje positivo.

En cuanto a su uso con una placa Arduino, no hay mucha diferencia entre ambos tipos de LED RGB. La única diferencia es que, en el caso del LED RGB con cátodo común, debes conectar las patillas de los colores a los pines digitales de la placa Arduino a través de resistencias y luego poner estos pines en alto (HIGH) para encender los colores, mientras que en el caso del LED RGB con ánodo común, debes conectar las patillas de los colores a los pines digitales de la placa Arduino a través de resistencias y luego poner estos pines en bajo (LOW) para encender los colores.

A continuación te presentamos un ejemplo de código en Arduino para controlar un LED RGB con cátodo común y otro para controlar un LED RGB con ánodo común:

Código para LED RGB con cátodo común:

const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  // Inicializamos los pines digitales como salidas
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Encendemos el LED rojo
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, LOW);
  delay(1000);

  // Encendemos el LED verde
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, LOW);
  delay(1000);

  // Encendemos el LED azul
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, HIGH);
  delay(1000);
}

Código para LED RGB con ánodo común:

const int redPin = 9;
const int greenPin = 10;
const int bluePin = 11;

void setup() {
  // Inicializamos los pines digitales como salidas
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  // Encendemos el LED rojo
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, HIGH);
  delay(1000);

  // Encendemos el LED verde
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, HIGH);
  delay(1000);

  // Encendemos el LED azul
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, LOW);
  delay(1000);
}

Una manera de distinguir entre un LED RGB con cátodo común y con ánodo común es observar la longitud de las patillas o pines del LED. En el caso del LED RGB con cátodo común, la patilla o pin común (cátodo) suele ser la más larga y se conecta al GND o a un voltaje negativo, mientras que las patillas o pines de los colores rojo, verde y azul suelen ser más cortas y se conectan a los pines digitales de la placa Arduino a través de resistencias.

En el caso del LED RGB con ánodo común, la patilla o pin común (ánodo) suele ser la más corta y se conecta a un voltaje positivo, mientras que las patillas o pines de los colores rojo, verde y azul suelen ser más largas y se conectan a los pines digitales de la placa Arduino a través de resistencias.

Otra forma de distinguir entre ambos tipos de LED RGB es revisar el datasheet o hoja de datos del LED. En este documento se suele especificar el tipo de LED (cátodo común o ánodo común) y el voltaje y corriente máximos que soporta cada patilla o pin.