Controlando leds

Uno de los aspectos importantes en la técnica del lightpainting es lo relativo a las herramientas, todo aquello con lo cual controlamos y/o modificamos la luz.

Y en esta ocasión voy a intentar desarrollar algo de lo aprendido hasta ahora en cuanto a controlar uno de los rudimentos mas fascinantes para mi: el LED!, y para ello voy a recurrir de manera gradual a integrar la electrónica y la programación.

Electrónica? Programación? No se nada!

Yo tampoco..

Pero entonces?

Entonces como no me especializo ni en electrónica ni en programación (bueno..tampoco en fotografía) voy a ir de a poco en lo que llevo aprendido a fuerza de maña, prueba y error y otro tanto investigar porque asi es como fui aprendiendo de cero.

Por eso mismo muchas cosas no las abordare de manera exhaustiva ni meticulosa (una forma elegante de no hablar de lo que no se) y seguramente cometa errores (y/o/u horrores!) por lo cual sugerencias y correcciones son mas que bienvenidas!

La finalidad es lograr que ambos aspectos confluyan en la técnica del lightpainting particularmente a través del uso de microcontroladores y ante todo dejar espacio a la creatividad!

Para empezar:

Arranco con lo mas básico y de a poco ir incorporando elementos (tampoco esperen una complejidad abrumadora)

– leds: empiezo bien sencillo con estos leds blancos de 1,5 mm

C:\lightpainting\blog\arduino 1\ende_IMG_2951.jpg

– resistencias: veremos de acuerdo al led como calcular el valor.

C:\lightpainting\blog\arduino 1\ende_IMG_2952.jpg

– protoboard: nada en particular, cualquiera es útil para montar de prueba nuestros experimentos.

C:\lightpainting\blog\arduino 1\ende_IMG_2944.jpg

– cables: lo ideal para mas comodidad son los que se compran ya preparados pero hacerlos con cualquier otro cable va a servir de todas formas.

C:\lightpainting\blog\arduino 1\ende_IMG_2950.jpg

– controlador arduino: hay una gran variedad de modelos cada cual con sus características, en mi caso por tamaño y precio voy a usar Nano que por ahora alcanza y sobra.

C:\lightpainting\blog\arduino 1\ende_IMG_2943.jpg

– IDE Arduino: la plataforma sobre la que vamos a programar el controlador y se descarga en https://www.arduino.cc/en/main/software

C:\lightpainting\blog\arduino 1\ide_arduino.jpg

El cosito que hace luz

El led (light emitter diode) podría decir que es la fuente de luz por excelencia ya que cuenta con una diversidad de usos y los hay de todo tipo, intensidad, color, etc.

De momento necesitamos lograr prender y apagar nuestro primer led para lo cual necesitamos saber lo mínimo acerca del led (tarea: investigar en detalle sobre los leds) ya que los hay de dos o mas patas pero todos tiene algo común:

-ánodo: pata del led que se conecta a positivo.

-cátodo: pata del negativo.

Podemos diferenciar cada uno de manera mas fácil que a simple vista:

-ánodo: pata larga

-cátodo: pata corta.

Lo siguiente a saber acerca de nuestro led (googleando obviamente) nos lleva a…

Voltaje y corriente

Hay mucho material al respecto y por gente que sabe a fondo del tema, el concepto mas descriptivo para entenderlo fácilmente es el siguiente:

https://i.pinimg.com/originals/4a/40/7a/4a407a97dc8b795c7d000cff85e8692e.jpg

El voltaje es la presión del caudal (corriente) y la resistencia limita esa corriente de ser necesario (o algo así..) y esto es algo continuamente presente porque tanto el led como el arduino tienen sus propias características y requerimientos con respecto a voltaje y corriente. Siguiendo el paralelismo de la ilustración podría pasar no tener suficiente presión o presión excesiva con el consiguiente daño, etc.

Para eso primero vamos a ver las especificaciones del led (información que hay buscar y puede variar)

Alimentación recomendada: 2,1V @ 20mA

Tensión min. de alimentación: 1,8V

Tensión máx. de alimentación: 2,4V

Lo cual nos da margen para el cálculo de la resistencia necesaria porque debemos saber que tensión y corriente nos darán las salidas de nuestro arduino que sería:

Tensión de salida de los pines 5v

Corriente 40mA

Por lo tanto va a ser necesaria una resistencia para no quemar el led, para esto hay infinidad de webs y aplicaciones que nos ayudan con dicho calculo.

Completamos los datos que ya tenemos disponibles y obtenemos el resultado:

C:\lightpainting\blog\arduino 1\calcula_res.jpg

en mi caso y para esos valores 145 ohms pero recordemos que tenemos margen con lo cual obtendremos distintos valores y además que los valores de las resistencias suelen ser estándar por lo tanto si del calculo resulta 141 ohms la resistencia disponible sea por ejemplo 140. No tiene que ser exacto gracias al margen de tensión.

Y donde va cada cosa?

C:\lightpainting\blog\arduino 1\nano_pinout.jpg

Como muestra el esquema (aunque de momento luzca indescifrable..) de las terminales del arduino (pinout) existen distintos tipos de pines y la mayoría para mas de un propósito que se especificara de acuerdo a la programación.

En nuestro caso necesitamos usar algunos de los pines digitales como salida porque esa señal será la encargada de encender y apagar el led y para el caso tomaremos el pin digital 3 (D3) hacia la resistencia y de ahi al led por un lado y por otro lado el negativo hacia el led

C:\lightpainting\blog\arduino 1\cableado.jpg

(claramente la resistencia no es de 140 ohms como me dio el cálculo sino de 220 ohms lo cual va a limitar aun mas la corriente y consecuentemente el led tendrá menos brillo)

Todo listo y conectado pasamos al IDE de Arduino y vamos con un código bien simple:

void setup() {
  pinMode(3, OUTPUT);
}

void loop() {
  digitalWrite(3,HIGH);
  delay(1000);
  digitalWrite(3,LOW);
  delay(1000);
}

lo subimos al arduino y si todo salio bien…..enhorabuena!!! logramos encender y apagar por primera vez un led con un microcrontrolador!

Ahora vamos a ver un poco de que se trata ya que queremos hacer algo mas que un led parpadeando.

Como dije al principio no voy a ser intensivo y extensivo en algunas cuestiones como por ejemplo en este caso lo relativo a la programación de arduino ya que existen cientos de webs y tutoriales al respecto para investigar además del sitio oficial donde encontraran todo sobre comandos, funciones, sintaxis, etc.

Asi que simplemente voy a notar lo siguiente:

lo primero que vemos es

void setup() {

….

}

Es una función siempre presente donde se declaran sentencias (entre llaves) que se ejecutan por única vez cuando se inicia el modulo y en este caso solo contiene la instrucción.

pinMode(3, OUTPUT);

Si consultamos la guía de referencia (https://www.arduino.cc/reference/es/) vemos que la función pinMode se encarga de configurar un puerto (el primer parámetro que corresponde al pin) como entrada o salida (segundo parámetro) por lo tanto estamos declarando al puerto 3 como una salida porque lo que necesitamos es que envíe al led el pulso para encenderlo o apagarlo.

Seguimos con un bloque

void loop() {

}

que es el que va contener todas las instrucciones que ejecutara el modulo de manera continua, es decir, se ejecutara línea por línea hasta el final del bloque y vuelve a la primera instrucción mientras el modulo siga alimentado.

digitalWrite(3,HIGH);

Es la función que se encarga de que el pin envíe 5v (cuando el segundo parámetro es HIGH) o 0v (cuando es LOW) al pin designado en el primer parámetro.

delay(1000);

Se encarga de pausar la ejecución del código la cantidad de milisegundos que especifique el parámetro.

Y asi sabemos ya de que se trata el código que sigue:

digitalWrite(3,LOW);

delay(1000);

El pin se «apagara» al enviarle 0v y luego otra pausa y como se llega al final de bloque vuelve a la primera instrucción donde enciende y etc, etc.

Hasta aca el primer paso logrado. Pero claro, quizas no sea lo mas emocionante andar revoleando un led en un protoboard con arduino asi que sabiendo que contamos con mas salidas digitales podemos avanzar otro paso programando ahora no uno sino dos o mas leds con un procedimiento similar al que vimos

por ejemplo voy a tomar 3 leds difusos de distinto color (rojo, amarillo, verde) y voy a saltear el paso del calculo de la resistencia y usar las mismas que el ejemplo anterior (cosa que no deberia hacer) y quedaria algo asi:

C:\lightpainting\blog\arduino 1\esquema_3leds.jpg

El pin 3 va hacia el rojo, el pin 4 al amarillo y el pin 5 al verde y pasamos al código donde vamos a agregar unos conceptos de programación para facilitar la legibilidad del código:

const int ledRojo = 3;          //configura pin 3 con la constante ledRojo
const int ledAmarillo=4;        //configura pin 4 con la constante ledAmarillo
const int ledVerde=5;           //configura pin 5 con la constante ledVerde
const int pausa=200;            //cantidad de milisegundos de pausa

void setup() {                  // bloque inicial
  pinMode(ledRojo, OUTPUT);     // configura los pines como salidas
  pinMode(ledAmarillo, OUTPUT);
  pinMode(ledVerde, OUTPUT);
}

void loop() {                     // bucle continuo donde ira encendiendo y apagando
  digitalWrite(ledRojo,HIGH);     // en orden cada led una y otra vez
  delay(pausa);
  digitalWrite(ledRojo,LOW);
  delay(pausa);
  digitalWrite(ledAmarillo,HIGH);
  delay(pausa);
  digitalWrite(ledAmarillo,LOW);
  delay(pausa);
  digitalWrite(ledVerde,HIGH);
  delay(pausa);
  digitalWrite(ledVerde,LOW);
  delay(pausa);
}

no solamente agregamos pines al código sino que aparecen algunas cosas nuevas como:

const int ledRojo = 3;

* la palabra reservada «const» se utiliza para declarar una constante, algo cuyo valor no se va a modificar en ningún punto del código de nuestro programa y esto nos facilita encontrar esos valores cuando el código empieza a ser extenso.

* seguido la palabra reservada «int» en referencia a que el valor de esa variable es un numero entero.

* «ledRojo» es el nombre que le vamos a dar a ese valor constante que luego se declara «=3».

* palabra reservada, tipos de datos, constantes, variables y mas es indispensable leer de la guía de referencia como dije anteriormente.

Luego sigue con el bloque donde especificamos que función van a tener los pines que vamos a utilizar pero esta vez utilizando el nombre de la constante que previamente declaramos, esto quiere decir que cada vez que aparezca la constante «ledRojo» estará haciendo referencia al valor entero de 3 y asi igual con las otras constantes declaradas. Esto también nos facilita el hecho de que si deseamos cambiar el pin 3 por otro en lugar de recorrer y cambiar cada línea de código donde especificamos pin 3 solo tenemos que modificar en la declaración de la constante por el valor que deseamos. Al igual que la constante » pausa», en lugar de modificar el valor de cada sentencia «delay» solo modificamos el valor de la constante en su declaración.

Luego el bloque que se repite una y otra vez donde cada led se enciende y apaga en orden y mas fácil de identificar cual gracias al uso de las constantes.

y que tal si probamos nuestra primer herramienta realizada con arduino!

C:\lightpainting\blog\arduino 1\prueba_led.jpg

Quizás no sea lo mas sorprendente pero lo que importa es ir sumando conocimiento para crear nuestras propias herramientas con microcontroladores e ir investigando!

Un paso a la vez

Hasta aca logramos lo mas importante que es encender un led (y apagarlo!) pero programándolo lo cual no es muy práctico si queremos hacerlo a voluntad en lugar de programar cada vez que queremos modificar el intervalo asi que vamos a agregar el uso de un pulsador y vamos a conectar de esta manera:

C:\lightpainting\blog\arduino 1\esquema_pulsador.jpg

* el pin 4 se encargara de enviar el pulso para encender y apagar el led

* el pin 3 configurado como entrada se encargara de chequear si el pulsador se activa, básicamente cuando circule corriente a través del pulsador.

Vamos al IDE de arduino con el siguiente codigo:

const int ledRojo = 4;          //configura pin 3 con la constante ledRojo
const int pulsador=3;           //configura pin 4 con la constante pulsador
int estado;

void setup() {                  // bloque inicial
  pinMode(ledRojo, OUTPUT);     // configura los pines como salidas
  pinMode(pulsador, INPUT);
}

void loop() { // bucle continuo donde ira encendiendo y apagando
  estado=digitalRead(pulsador);
  if (estado==HIGH){
    digitalWrite(ledRojo,HIGH);     // en orden cada led una y otra vez
  }
  else {
  digitalWrite(ledRojo,LOW);
  }
}

* Declaramos una constante para el pin 4 y otra para el pin 3

* Esta vez configuramos al 3 (asignado a la constante «pulsador») como entrada.

* «estado» se encarga de guardar el estado del pin de entrada por eso no se declara como constante sino como variable porque justamente el valor va a cambiar a lo largo de la ejecución del codigo.

* se declaran los pines como salida «pinMode(ledRojo, OUTPUT)» y entrada » pinMode(pulsador, INPUT)».

* una vez que empieza el bucle «estado=digitalRead(pulsador)» toma el estado del port del pulsador con el comando «digitalRead». Si esta inactivo el valor será «LOW» (0v) caso contrario «HIGH» lo cual sucede cuando se mantiene presionado el pulsador.

* el bloque IF/THEN compara el valor del estado del port del pulsador, si esta activo enciende el led y sino lo mantiene apagado.

Si todo salio bien….podriamos decir que tenemos nuestra primer linterna microcontrolada y tenemos mas cosas con las cuales combinar asi que vamos a darle algo mas de funcionalidad con el siguiente codigo y a ver de que se trata:

const int ledRojo = 4;          //configura pin 3 con la constante ledRojo
const int pulsador=3;           //configura pin 4 con la constante pulsador
int estado;
int modo=0;

void setup() {                  // bloque inicial
  pinMode(ledRojo, OUTPUT);     // configura los pines como salidas
  pinMode(pulsador, INPUT);
}

void loop() {                     // bucle continuo donde ira encendiendo y apagando
  estado=digitalRead(pulsador);   // chequeamos el estado del pulsador
  if (estado==HIGH){              // esta presionado el pulsador?
    delay(500);                   // espera 500 ms para chequear luego si sigue presionado
    modo++;                       // se incrementa la variable modo para pasar al siguiente
    if (modo > 2){                // si llega al ultimo modo pasa al primero
      modo=0;
    }
  }

  switch (modo) {                   // la estructura switch se encarga de activar cada modo
    case 0:                         // de acuerdo a nuestra variable de control
      digitalWrite(ledRojo,LOW);    // el modo 0 se mantiene apagado como el estado inicial
    break;
    case 1:
      digitalWrite(ledRojo,HIGH);   // el modo 1 encienden continuo el led
    break;
    case 2:                         // el modo 2 hace parpadear el led
      digitalWrite(ledRojo,HIGH);
      delay(200);
      digitalWrite(ledRojo,LOW);
      delay(200);
    break; 
  }
}

* lo primero es agregar una variable de control «modo» que se encargara de guardar el modo en que estará funcionando el led, cada vez que pulsamos se incrementa la variable y se vuelve a cero en caso que llegue al ultimo modo.

* luego vemos que se chequea el estado del pulsador y si esta activo se hace una pausa y se vuelve a chequear.

Ese doble chequeo es para eliminar la posibilidad del efecto rebote del pulsador (recomiendo buscar en detalle sobre el tema) y es una de las tantas formas de hacerlo ya que se puede hacer tanto por medio de la programación como por medio de componentes. En este caso elegí hacerlo de esta forma.

* si efectivamente se mantuvo pulsado se incrementa la variable de control de modo y también se comprueba que llegado al último modo el siguiente sea el primero.

* incorporamos una estructura nueva «switch…case» la cual se encarga de evaluar una variable y de acuerdo al valor ejecutar un código en particular:

* cuando modo es igual a 0 el led se mantiene apagado.

* cuando modo es igual a 1 el led se mantiene encendido.

* cuando modo es igual a 2 el led parpadea a intervalos de 200 ms.

Esto es parte de la creatividad en el aspecto de la programación de arduino de como un simple componente como el pulsador nos permite realizar todo tipo de tareas.

Por ejemplo podría usar dos pulsadores, uno para pasar al modo siguiente y otro para pasar al modo anterior, etc, etc….tarea para desarrollar!

A veces es a la inversa

Vamos con el caso particular de los leds RGB de 4 patas de ánodo común, es decir que tienen un positivo común y a cada pata de color el negativo. Por lo tanto si no se envía un pulso al pin del color como veníamos iniciando el código, el led permanecerá encendido ya que llegan …… 0V !.

C:\lightpainting\blog\arduino 1\ledrgb.jpg

(no se dejen llevar por el deplorable aspecto, es el único que encontré…)

de izquierda a derecha en esta vista las patas son Rojo, +, Verde y Azul.

veamos el esquema pero tengan en cuenta que el valor de la resistencia de 220ohms es solamente ilustrativo, cada color tiene su tensión y para no tener desviación hay que buscar la info correspondiente y calcular la resistencia necesaria (tarea!).

C:\lightpainting\blog\arduino 1\esquema_rgb.jpg

y pasamos al codigo pero para comprobar como cambia al ser anodo comun vamos a configurar como lo veniamos haciendo

const int ledRojo = 4;          
const int ledVerde = 5; 
const int ledAzul =6; 

void setup() {                  
  pinMode(ledRojo, OUTPUT);  
  pinMode(ledVerde, OUTPUT); 
  pinMode(ledAzul, OUTPUT); 
}

void loop() {                     
}

pasamos el codigo al arduino y vemos que el led enciende todos los colores (lo que deberia dar blanco) sin que hayamos enviados el pulso a cada pin. El anodo que esta haciendo el alimentado y cada pin enviando 0 v hace que se encienda.

Vamos a hacer unos ajustes

const int ledRojo = 4;          
const int ledVerde = 5; 
const int ledAzul =6; 
void setup() {                  
  pinMode(ledRojo, OUTPUT);     // configura los pines como salidas
  pinMode(ledVerde, OUTPUT); 
  pinMode(ledAzul, OUTPUT); 
  digitalWrite(ledRojo,HIGH);   // mantenemos los pines en alto para iniciar los colores apagados
  digitalWrite(ledVerde,HIGH);
  digitalWrite(ledAzul,HIGH);
}

void loop() {                     
  digitalWrite(ledRojo,LOW);    // deja el pin en estado bajo con lo cual son 0v y el rojo se enciende
  delay(1000);
  digitalWrite(ledRojo,HIGH);   // deja el pin en estado alto con lo cual son 5v y el rojo se apaga y asi con los demas pines
  delay(1000);

  digitalWrite(ledVerde,LOW);
  delay(1000);
  digitalWrite(ledVerde,HIGH);
  delay(1000);

  digitalWrite(ledAzul,LOW);
  delay(1000);
  digitalWrite(ledAzul,HIGH);
  delay(1000);
}

Ahora si! iniciamos los pines en estado alto para que los leds se mantengan apagados y luego en el ciclo pasan a estado bajo para encenderlos de a un color a la vez y obviamente que se pueden encender mas de uno a la vez para combinar y tener toda una gama de colores!

Pero vamos a hacerlo agregando un pulsador para ir pasando de color y combinacion

C:\lightpainting\blog\arduino 1\esquema_rgb_pulsador.jpg
const int ledRojo = 4;          
const int ledVerde = 5; 
const int ledAzul =6;         
const int pulsador=3;          
int estado;
int modo=0;

void setup() {                 
  pinMode(pulsador, INPUT);
  pinMode(ledRojo, OUTPUT);     
  pinMode(ledVerde, OUTPUT); 
  pinMode(ledAzul, OUTPUT); 
  digitalWrite(ledRojo,HIGH);   
  digitalWrite(ledVerde,HIGH);
  digitalWrite(ledAzul,HIGH);
}

void loop() {                     
  estado=digitalRead(pulsador);   
  if (estado==HIGH){              
    delay(500);                   
    if (estado==HIGH){ 
        modo++;                       
        if (modo > 7){                
          modo=0;
        }
    }
  }

  switch (modo) {                   
    case 0:                         // modo 0 todo apagado
      digitalWrite(ledRojo,HIGH);
      digitalWrite(ledVerde,HIGH);
      digitalWrite(ledAzul,HIGH);
    break;
    
    case 1:                         // modo 1 enciende rojo
      digitalWrite(ledRojo,LOW);
      digitalWrite(ledVerde,HIGH);
      digitalWrite(ledAzul,HIGH);
    break;
    case 2:                         // el modo 2 enciende verde
      digitalWrite(ledRojo,HIGH);
      digitalWrite(ledVerde,LOW);
      digitalWrite(ledAzul,HIGH);
    break;
    case 3:                         // el modo 3 enciende azul
      digitalWrite(ledRojo,HIGH);
      digitalWrite(ledVerde,HIGH);
      digitalWrite(ledAzul,LOW);
    break; 
    case 4:                         // el modo 4 rojo+verde=naranja
      digitalWrite(ledRojo,LOW);
      digitalWrite(ledVerde,LOW);
      digitalWrite(ledAzul,HIGH);
    break;
    case 5:                         // el modo 5 verde+azul=celeste
      digitalWrite(ledRojo,HIGH);
      digitalWrite(ledVerde,LOW);
      digitalWrite(ledAzul,LOW);
    break;  
    case 6:                         // el modo 6 rojo+azul=magenta
      digitalWrite(ledRojo,LOW);
      digitalWrite(ledVerde,HIGH);
      digitalWrite(ledAzul,LOW);
    break; 
    case 7:                         // el modo 7 rojo+verde+azul=blanco
      digitalWrite(ledRojo,LOW);
      digitalWrite(ledVerde,LOW);
      digitalWrite(ledAzul,LOW);
    break;  
  }
}

En esta ocasión simplemente definimos mas modos en la estructura CASE…SWITCH y teniendo en cuenta de que al cambiar de estado mantener en alto la señal de los pines que deben estar apagados

Controlando el brillo

Hasta aca todo fue encender o apagar los leds agregando conceptos tanto con la programación como los componentes y nos faltaría poder controlar el brillo!

Para eso vamos a agregar el uso de un potenciómetro y por el lado de la programación el uso del modulo de conversión analógico/digital y salida PWM.

No me voy a detener en detalle sobre estos últimos aspectos ya que hay material de sobra y desarrollados de forma extensiva pero básicamente seria algo asi:

– un puerto analógico se encargara de leer el valor del voltaje del potenciómetro y el modulo ADC se encargara de comparar el nivel de entrada con el voltaje de referencia para convertirlo a un valor digital.

– ese valor será enviado a un puerto digital pero utilizando la modulación de ancho de pulso (PWM= Pulse Width Modulation) lo cual hace variar el brillo del led.

C:\lightpainting\blog\arduino 1\esquema_rgb_pote.jpg

Y el siguiente codigo, para hacerlo simple y claro solo controlar el brillo del canal verde del led.

const int ledRojo = 4;          
const int ledVerde = 5; 
const int ledAzul =6;         
const int pote=A0;  // El puerto Analogico A0 sera utilizado para leer el valor del potenciometro
int brillo=0;        

void setup() {                 
  pinMode(ledRojo, OUTPUT);     
  pinMode(ledVerde, OUTPUT); 
  pinMode(ledAzul, OUTPUT); 
  pinMode(pote, INPUT);  // se declara como entrada para poder leer el valor del potenciometro
  digitalWrite(ledRojo,HIGH);   
  digitalWrite(ledVerde,HIGH);
  digitalWrite(ledAzul,HIGH);
}

void loop() {                     
      brillo = analogRead (pote)/4;  // lee el valor
        analogWrite(ledVerde, brillo);  // envia el el valor de brillo utilizando PWM
  }

Vemos una notable diferencia de que en este caso tanto la lectura como la escritura de los puertos se hace de manera analogica a diferencia de las pruebas anteriores utilizando digitalWrite y de esta forma podemos agregar potenciometros y salidas PWM para los otros colores y tener un total control del led: encendido, apagado y brillo!

Y de esto se trata la idea de integrar la electronica con programacion para desarrollar herramientas, de partir de rudimentos y entender como funcionan para ir dandole la complejidad de acuerdo a nuestras necesidades. Hay todo un mundo para explorar!

A practicar y crear!

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *