Introduction: ¡Manejemos Los Leds!

By Conoce más sobre nuestra comunid
About: Somos el espacio de imaginación, experimentación y prototipado de la PUCV.

¡Hola a tod@s! ¿Listos para aprender un poquito sobre Arduino? Hoy haremos un proyecto donde prenderemos y apagaremos una corrida de leds con una placa Arduino UNO (tu puedes usar cualquier otra si no dispones de esta), si quieres revisar el circuito en Tinkercad puedes hacerlo aquí, los objetivos de la actividad son:

  • Aprender a manejar los puertos digitales y análogos de salida.
  • Aprender algunas funciones básicas de programación.

¿Listo?

Supplies

Los materiales que usaremos son:

  • 1 x Arduino UNO.
  • 1 x protoboard.
  • 1 x Potenciómetro de 10k Ohm
  • 6 x Leds rojos.
  • 6 x Resistencias de 220 Ohm.
  • Jumprers/cables varios.

Step 1: ¡Preparemos La Base Para Trabajar!

Primero que nada debemos abrir Tinkercad Circuits y poner nuestra Arduino y protoboard para trabajar, entonces:

  1. Dirigite a la pestaña de componentes Básicos y selecciona Arduino, tal cual se ve en la imagen 1.
  2. Arrastra el Arduino + placa de pruebas al espacio de trabajo (imagen 2 como referencia).

Si estas trabajando con una Arduino real solo debes conectar los jumpers/cables como se muestra en la imagen 2.

¡Listo!

Step 2: ¡Agreguemos Los Componentes! - Resistencias

Ya teniendo la base lista es hora de agregar el resto de componentes, empezaremos por los las resistencias, entonces:

  1. Seleccionar la pestaña "Startes Arduino" y seleccionar "Básico" (imagen 1 de referencia).
  2. Arrastrar la resistencia hacia la protooard 6 veces para tal cual se aprecia en la imagen 2.
  3. Hacer click en una de las resistencias y cambiar su valor a 220 ohm, puedes ver la imagen 3 para tener una referencia.
  4. Conectar las resistencias a sus respectivos pines en arduino, ve la imagen 4 para ver cuales son y como van.

Si estas trabajando con una Arduino real solo debes conectar las resistencias como se muestra en la imagen 4.

¡Listo!

Step 3: ¡Agreguemos Los Componentes! - Leds

Para poder agregar los leds rojos debemos:

  1. Arrastrar los 6 leds a la protoboard, tal cual se ven en la imagen 1, es importante que la patita doblada (ánodo) esté conectada a la resistencia, mientras que la recta (cátodo) no, si te sientes confundid@ puedes ver la imagen 2.
  2. Luego se deben conectar las patitas rectas a la tierra, cómo debe quedar se puede ver en la imagen 3.

Si estas trabajando con una Arduino real solo debes conectar los leds como se muestra en la imagen 3.

¡Listo!

Step 4: ¡Agreguemos Los Componentes! - Potenciómetro

Para poder conectar el potenciómetro debemos:

  1. Arrastrarlo a la protoboard y cambiar su valor a 10k Ohm, tal cual se ve en la imagen 1.
  2. Conectarlo a la linea de 5 V (rojas), a tierra (negra), y a la entrada análoga A0 (verde), puedes ver como queda en la imagen 2.

Si estas trabajando con una Arduino real solo debes conectar el potenciómetro como se muestra en la imagen 2.

¡Listo!

Step 5: ¡Hora De Programar!

Ahora nos ensuciaremos las manos programando, primero debemos abrir la pestaña de código:

  1. Seleccionar la pestaña de código (imagen 1).
  2. Si entraste al link de Tinkercad Circuits que señalamos en la introducción debería aparecer el código que se muestra (y entenderemos enseguida) en la imagen 2.

Si estas desde una Arduino real solo debes abrir el entorno de programación Arduino IDE.

El código a implementar lo dividiremos en secciones para explicarlo, el cual es:

int tiempo_fade = 0;
int pines_led[6] = {3, 5, 6, 9, 10, 11};

void setup()
{
  pinMode(pines_led[5], OUTPUT);
  pinMode(pines_led[4], OUTPUT);
  pinMode(pines_led[3], OUTPUT);
  pinMode(pines_led[2], OUTPUT);
  pinMode(pines_led[1], OUTPUT);
  pinMode(pines_led[0], OUTPUT);
  digitalWrite(pines_led[0], LOW);
  digitalWrite(pines_led[1], LOW);
  digitalWrite(pines_led[2], LOW);
  digitalWrite(pines_led[3], LOW);
  digitalWrite(pines_led[4], LOW);
  digitalWrite(pines_led[5], LOW);
}

void loop()
{
  for(int led = 0; led < 6; led++)
  {
    for(int brillo = 0; brillo < 256; brillo+=5)
    {
      tiempo_fade = 1+analogRead(0)/256;
      analogWrite(pines_led[led], brillo);
      delay(tiempo_fade);
    }
    for(int brillo = 255; brillo > 0; brillo-=5)
    {
      tiempo_fade = 1+analogRead(0)/256;
      analogWrite(pines_led[led], brillo);
      delay(tiempo_fade);
    }
  }
}

Primero expliquemos para qué sirven las variables al inicio del programa:

int tiempo_fade = 0;
int pines_led[6] = {3, 5, 6, 9, 10, 11};

Queremos controlar el tiempo de encendido y apagado entre los leds, para lograr esto usamos un potenciómetro donde el rango de éste se traduce en milisegundos (un segundo dividido en mil) a esperar, este valor debe ser almacenado en algún lugar para poder ser usado, aquí es donde entra tiempo_fade, es la variable creada para almacenar el tiempo de espera. En lo que respecta los leds, ya sabemos que debemos conectarlo a la Arduino que estemos usando, para lograr algo que veremos enseguida en otra parte del código usaremos un Array, esto es una variable que puede almacenar muchos valores, puedes pensar en esto como un mueble con muchos cajones (6 en este caso) donde solo podemos guardar un objeto (o un valor) en cada uno, pines_led[6] es una Array donde guardaremos los pines a usar donde el [6] indicamos la cantidad de variables (y objetos si pensamos en el mueble) que almacenaremos (pin 3, pin 5, pin 6... y así hasta llegar al pin 11).

¿Y luego de declarar las variables que necesitamos? Debemos establecer las configuraciones iniciales mediante la función void setup() tal cual vemos a continuación:

void setup()
{
  pinMode(pines_led[5], OUTPUT);
  pinMode(pines_led[4], OUTPUT);
  pinMode(pines_led[3], OUTPUT);
  pinMode(pines_led[2], OUTPUT);
  pinMode(pines_led[1], OUTPUT);
  pinMode(pines_led[0], OUTPUT);
  digitalWrite(pines_led[0], LOW);
  digitalWrite(pines_led[1], LOW);
  digitalWrite(pines_led[2], LOW);
  digitalWrite(pines_led[3], LOW);
  digitalWrite(pines_led[4], LOW);
  digitalWrite(pines_led[5], LOW);
}

Los pines (o puertos) digitales y análogos pueden funcionar como entradas o salidas y debemos decirle a la Arduino como los queremos usar, para esto usamos la función pinMode(A,B) donde A representa el pin que queremos configrar y B es el cómo lo vamos a usar, por ejemplo pinMode(pines_led[0], OUTPUT) nos dice lo siguiente "Arduino quiero que el pin almacenos en la posición 0 de la variable pines_led quede configurado para ser usado como salida"¿Posición 0 de la variable pines_led? ¿No debería ser posición 1? Por temas de como se almacenan y conforman los datos y las variables es importante saber o recordar que en Arduino todo Array almacena valores (como el mueble lo hace con los objetos), solo que para poder llamar cualquier valor debemos empezar por el 0 como posición inicial (como si el primer cajón del mueble le llamaremos cajón 0. al segundo cajón 1 y así), entonces si queremos usar el pin 6 tendríamos que usar la posición de Array 2. Luego de configurar todos los pines es necesario ponerlos todos en estado bajo (o apagado), esto se realiza mediante la función digitalWrite(A, B) que nos dice "Arduino, quiero que el pin A esté en estado B)", donde B es LOW si se quiere apagar el led, o HIGH si se quiere prender.

¿Y que son esas funciones raras dentro de void loop()? Primero que nada recordemos que void loop() es un función que repetirá todas las instrucciones que están dentro de esta en orden una y otra vez, hasta que la Arduino se apague o deje de funcionar, para entender las instrucciones primero simplifiquemos esto:

void loop()
{
  for(int led = 0; led < 6; led++)
  {
    for(int brillo = 0; brillo < 256; brillo+=5)
    {
      tiempo_fade = 1+analogRead(0)/256;
      analogWrite(pines_led[led], brillo);
      delay(tiempo_fade);
    }
    for(int brillo = 255; brillo > 0; brillo-=5)
    {
      tiempo_fade = 1+analogRead(0)/256;
      analogWrite(pines_led[led], brillo);
      delay(tiempo_fade);
    }
  }
}

A esto:

void loop()
{
  for para cambiar el led que se usa
  {
    for para aumentar el brillo del led{}
    for para disminuir el brillo del led{}
  }
}

Antes de empezar a explicar el código debemos entender lo que hace la función for(A, B, C){}, esencialmente repite el código que está entre {} mientras una condición sea satisfecha, esta se explicita en B, mientras que en A se pone una variable con un valor inicial deseado, entonces si tengo for(int i = 0, i < 5, C){} quiere decir que "repite el código mientras i sea menor a 5", pero ¿Para qué esta C? si tenemos una variable y una condición solo nos falta el cambio que sufre la variable i en cada iteración por lo que si se tiene for(int i = 0, i < 5, i++){}, esto quiere decir que "repite el código mientras i sea menor a 5, cada vez que pases por todas la lines dentro de {} incremente i en 1".

Ahora que ya lo tenemos claro veamos que hace el for para cambiar el led que se usa, o sea, for(int led = 0; led < 6; led++), lo cual nos dice "inicia la variable led en 0, mientras sea menor a 6 ejecuta las instrucciones que tines,luego de cara iteración incrementa el valor en 1" ¿Recuardas que te habñia dicho que después ibamos a ver por qué guardamos los pines a usar en un Array? Para cambiar el pin que se está manejando con un for, piensalo, si led empieza en 0 el for para cuando su valor es 6, pero los valores usados son de 0 a 5, por que cuando la condición no se cumple el for para, estos son justo los valores que se pueden usar en pines_led[] para llamar a sus variables ¡esto posibilita que podamos usarla en el for para aumentar y disminuir el brillo de los leds de manera iterativa y compacta!

Ahora veamos que hay dentro del for para aumentar el brillo el led:

    for(int brillo = 0; brillo < 256; brillo+=5)
    {
      tiempo_fade = 1+analogRead(0)/256;
      analogWrite(pines_led[led], brillo);
      delay(tiempo_fade);
    }

Vemos que el for tiene los siguientes argumentos, el brillo como varialbe iniciada en 0, la condición es que el brillo debe ser menor que 256 y luego de cada iteración la variable es aumentada en un valor de 5 (se le suma 5), luego tenemos la variable tiempo_fade donde se almacena el valor del potenciómetro obtenido mediante analogRead(0) convertido a milisegundos mediante el factor de 1/256, en la función analogWrite(pines_led[led], brillo) seleccionamos el led a controlar y el brillo que queremos que tenga, el cual aumenta hasta llegar de 0 a 255, antes de terminar la iteración esperamos los milisegundos establecidos anteriormente, lo que se traduce en que el led irá aumentado su brillo progresivamente en un tiempo de (255/5)*tiempo_fade milisegundos.

Con respecto al for para disminuir el brillo del led tenemos:

    for(int brillo = 255; brillo > 0; brillo-=5)
    {
      tiempo_fade = 1+analogRead(0)/256;
      analogWrite(pines_led[led], brillo);
      delay(tiempo_fade);
    }

Podemos apreciar que todo es practimante igual a excepción de los argumentos del for, primero iniciamos la variable en 255 (el cual es el máximo brillo, o sea, el que quedó del for anterior), la condición es que éste sea mayor a 0 ya que el incremento en este caso es negativo, o sea, disminuye de 5 en 5 para cada iteración, esto resulta en que el led irá de su máximo brillo a estar apagado en un tiempo igual al anterior.

¡Ya estamos listos con la programación!

Step 6: ¡Veamos Como Nos Quederon Esos Leds!

Step 7: ¿Por Qué Las Cosas Funcionan?

Ya nos quedó claro que los pines pueden ser usados como entrada o salida, pero ¿Que entra o sale? ¡Electrones! Así es la energía que fluye lo hace de manera eléctrica, o sea, se mueven o no electrones, al flujo de estos se le llama "corriente".

Cuando decimos que los pines esten en alto (HIGH) o bajo (LOW) lo que realmentede indicamos es su tensión, que sea 0 V o 5 V., esta es otra característica de la energía eléctrica e indica la fuerza con la que los electrones viajan por los cables

¿Y para que se usa la resistencia? si recuerdas bien las pusimos entre los leds y los pines de salida, su función es regular la corriente que fluye, entonces, si ya sabemos que hay corriente cuando la tansión de salida es 5 V y tenemos el valor de la resistencia podemos calcular la corriente que fluye mediante:

(tensión de salida - tensión del led)/(resistencia) = corriente

(5-1.2)/(220) = 17.3 mA


Es importante tener en cuenta esto ya que si la corriente supera cierto valor podemos quemar los leds o dañar la Arduino, a la relación entre resisntencia, tensión y corriente se le lama Ley de Ohm.

En lo que respecta al potenciómetro, podemos pensar en este como dos resistencias que cambian su valor, pero que la suma de estas sigue siendo siempre la misma (10k Ohm en este caso), si la resistencia total y la tensión es siempre la misma, entonces la corriente igual lo es, el truco está en que la resistencia por la corriente equivale a tensión:

corriente*resisntencia = tensión (Ley de Ohm)

entonces si internamente las resisntencias cambian de valor, pero no lo hace la corriente, la tensión entre las patitas del potenciómetro cambia, es esto lo que mide la arduino, puedes ver el siguiente vídeo para visualizar la explicación mejor: