Salidas analógicas en Arduino. Intensidad lumínica.

El objetivo de este proyecto es regular la intensidad de un led usando las salidas que soportan PWM y que corresponden a los pines digitales con el símbolo "~". En primer lugar, cambiaremos la intensidad de un solo led. Seguidamente, lo haremos con 3 leds, uno azul, otro verde y otro rojo; y por último, lo haremos con un led RGB, con los tres colores primarios y las resistencias ya integradas.

Los leds (como tantos otros) son dispositivos analógicos. Esto implica que pueden tener muchos más estados; de hecho, pueden tener estados continuos. Es decir, que pueden iluminarse con muchas intensidades diferentes y de forma gradual.

El microcontrolador de Arduino Uno posee conversores anológicos digitales capaces de enteder el valor que recibe por las entradas analógicas, pero no tiene salidas analógicas puras, y para solucionar esto, usa la técnica de PWM. Arduino implementa por hardware salidas PWM en varios de sus pines, los cuales aparecen identificados en la placa con el símbolo ~ junto al número del pin.

Cambiar la intensidad lumínica de un LED.

En este ejemplo conseguiremos que un led vaya aumentando su intensidad lumínica: se apagará y volverá a encenderse.

Material necesario:

• Arduino Uno o similar.
• Protoboard.
• Cables.
• Led
• 1 resistencia de 220 Ohms.

Vamos a montar el esquema para la práctica: el cátodo del led lo conectaremos al pin 9, que es una salida PWM, y el ánodo lo conectaremos a tierra a través de una resistencia de 220 Ohm. Veámoslo en la siguiente imagen:

Código:

int intensidad = 0;
int incremento = 5;   //Puede valer negativo (decremento)
void setup(){
  pinMode(9, OUTPUT); //El LED está conectado al pin 9 (PWM)
}
void loop() {
  analogWrite(9, intensidad);
  intensidad = intensidad + incremento;
  /* Invertir  */
  if (intensidad == 0 || intensidad == 255) {
    incremento = -incremento;
  }
  delay(40);  // tiempo de espera
}

Se han creado dos variables: una donde vamos a guardar el valor de la intensidad y otra, que indica en cuánto se va a incrementar la intensidad en cada vuelta.

En la función setup() configuramos el pin 9 como salida con la instrucción pinMode().

Y en el bucle loop(), lo primero que hacemos es encender el led con el valor de la variable intensidad (en el inicio su valor es 0). Después se irá incrementando de 5 en 5. Hay un momento que pasará de 255, para eso hemos puesto un if que invertirá el valor de la variable incremento en el momento en el que alcance el valor 255 ó 0. De esta forma la intensidad del led cambia constantemente: primero, aumenta; luego, disminuye y así sucesivamente.

Manipular el brillo de un LED a voluntad mediante el envío de la intensidad.

En el siguiente ejemplo tenemos 3 leds diferentes (de colores primarios rojo, verde y azul, respectivamente) conectados, cada uno, a través de su divisor de tensión correspondiente a un pin PWM diferente. La idea es modificar el brillo enviándolo por el monitor serial. Por ejemplo, si queremos apagar el led rojo, lo haríamos con r0 y si queremos encender, con r255. Para encender el led azul a media intensidad, lo haríamos con b125.

Material necesario:

• Arduino Uno o similar.
• Protoboard.
• Cables.
• 3 leds: azul, verde y rojo 3
• resistencias de 220 Ohms.

char color;   //Es importante que sea de tipo char y no byte
byte brillo;

void setup() {
  Serial.begin(9600);
  pinMode(5, OUTPUT); // Pin configurados como salida
  pinMode(6, OUTPUT);
  pinMode(9, OUTPUT);
  analogWrite(5, 127); // Establezco un brillo inicial medio
  analogWrite(6, 127);
  analogWrite(9, 127);
}
void loop () {
  // Leo el primer caracter recibido por el canal serie
  if (Serial.available()>0) {
    color=Serial.read();
    if( color == 'r' || color == 'g' || color == 'b' ) {
      delay(5);
      // Extraigo el número que sigue a la primera letra
      brillo=byte(Serial.parseInt());
      if(color == 'r') {
        analogWrite(5, brillo);
      }else if(color == 'g'){
        analogWrite(6, brillo);
      }else if(color == 'b'){
        analogWrite(9, brillo);
      }
    }
  }
  delay(100); // Me espero para recibir los datos serie correctamente
}

Para cambiar la intensidad de los leds indicamos la inicial del color (r, g o b) y a la intensidad le damos un valor entre 0 y 255.

Si deseamos hacerlo más facil a la hora de introducir los datos, utilizamos el mismo circuito pero cambiando el código. Podemos modificar la intensidad introduciendo los tres datos separados por comas (r,g,b), por ejemplo:(100,50,200).

byte brilloRojo, brilloVerde, brilloAzul;

void setup() {
  Serial.begin(9600);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(9, OUTPUT);
  analogWrite(5, 127);
  analogWrite(6, 127);
  analogWrite(9, 127);
}
void loop () {
  //Leo todos los caracteres recibidos por el canal serie
  while (Serial.available()>0) {
    //Busco el siguiente número entero válido en los datos entrantes
    brilloRojo = Serial.parseInt();
    //Repito la búsqueda
    brilloVerde = Serial.parseInt();
    //Repito la búsqueda
    brilloAzul = Serial.parseInt();
    //Miro si ha llegado el caracter de nueva línea: eso marca el fin
    if (Serial.read() == '\n') {
      //Restrinjo los valores leídos al rango 0-255, por si acaso
      brilloRojo = constrain(brilloRojo, 0, 255);
      brilloVerde = constrain(brilloVerde, 0, 255);
      brilloAzul = constrain(brilloAzul, 0, 255);
      //Ilumino los LEDs convenientemente
      analogWrite(5, brilloRojo);
      analogWrite(6, brilloVerde);
      analogWrite(9, brilloAzul);
    }
  }
}

Lámpara de mezcla de colores. Led RGB.

El objetivo de esta práctica es probar el funcionamiento del diodo led RGB de ánodo común con 4 pin F5 5MM y el módulo RGB KY-016 con 3 colores que ya integra las resistencias.

El primero que vamos a probar es el diodo led de ánodo común con 4 pin F5

Material necesario:

• Arduino Uno o similar.
• Protoboard.
• Cables.
• Led RGB de anodo comun con 4 pin F5
• 3 resistencias de 220 Ohms.

En el esquema podemos ver como la patilla de cada color la hemos conectado con un pin PWM a través de una resistencia de 220 Ohm. La patilla azul al pin 11, la roja, al 10 y la verde, al 9. Y el ánodo común a tierra.

int LedVerde = 9;
int LedRojo = 10;
int LedAzul = 11;

void setup() {
  pinMode(LedRojo, OUTPUT);
  pinMode(LedVerde, OUTPUT);
  pinMode(LedAzul, OUTPUT);
}

void loop() {
  // Rojo
  analogWrite(LedRojo, 255);
  analogWrite(LedVerde, 0);
  analogWrite(LedAzul, 0);
  delay(2000);
  // Verde
  analogWrite(LedRojo, 0);
  analogWrite(LedVerde, 255);
  analogWrite(LedAzul, 0);
  delay(2000);
  // Azul
  analogWrite(LedRojo, 0);
  analogWrite(LedVerde, 0);
  analogWrite(LedAzul, 255);
  delay(2000);
}

Seguidamente, probamos el módulo RGB KY-016 con 3 colores. Hay que tener en cuenta que este módulo lleva incorporadas las resistencias.

Material necesario:

• Arduino Uno o similar.
• Protoboard.
• Cables.
• Módulo led de 3 colores RGB KY-016

El esquema es como el anterior pero sin colocar las resistencias, que están incorporadas en el módulo, como ya sabemos.

const int PinLedRojo = 11;
const int PinLedVerde = 10;
const int PinLedAzul = 9;
 
void setup() 
{
  Serial.begin(9600);    
  pinMode(PinLedVerde, OUTPUT);
  pinMode(PinLedRojo, OUTPUT);
  pinMode(PinLedAzul, OUTPUT);
}
 
void loop() {
  // Verde
  Serial.println("¡Verde!");
  digitalWrite(PinLedRojo, LOW);
  digitalWrite(PinLedVerde, HIGH);
  digitalWrite(PinLedAzul, LOW);
  delay(500);
  // Rojo
  Serial.println("¡Rojo!");
  digitalWrite(PinLedRojo, HIGH);
  digitalWrite(PinLedVerde, LOW);
  digitalWrite(PinLedAzul, LOW);
  delay(500);
  // Azul
  Serial.println("¡Azul!");
  digitalWrite(PinLedRojo, LOW);
  digitalWrite(PinLedVerde, LOW);
  digitalWrite(PinLedAzul, HIGH);
  delay(500);
}