Diodo LED.

Introducción y ejemplo
Diodo LED, ¿qué es?
Un diodo LED es un componente electrónico capaz de transmitir luz. Emite dicha luz cuando la corriente
eléctrica lo atraviesa,  y lo hace, además, de forma proporcional. A más intensidad de corriente
atravesándolo, más luz.
Puede ser conectado ya sea polarización directa como inversa, aunque sólo funcionará si se encuentra
conectado de forma directa.
La manera de distinguir el ánodo ( terminal positivo) del cátodo (terminal negativo) es fijándonos en la
longitud de las patillas del diodo. El ánodo es más largo que el cátodo.

Se dibujan las flechas para indicar que se trata de un diodo LED.

LED rojo
Hay que tener en cuenta que, cuando vayamos a conectarlo para diseñar un circuito con nuestro Arduino
UNO, es necesario conectar una resistencia en serie al diodo, así limitamos la intensidad que circula y
evitamos que pueda ser dañado.

¿Qué valor mínimo de resistencia es recomendable?

Según la ley de Ohm, cuanto mayor sea el valor de la resistencia, menos intensidad circulará por el diodo,
y menos luz emitirá. La intensidad con la que funciona correctamente un diodo LED es de unos 15mA, por
lo que lo podemos resolver conectando una resistencia de 220 ohminos en serie.

Primero de todo, vamos a ver cómo funciona la placa breadboard. 

Vemos que arriba y abajo posee dos líneas (azul y roja, respectivamente). Estas líneas con agujeritos, se
llaman buses. La línea roja indica el bus sometido al voltaje de entrada, y la línea azul será la conectada a
tierra. Todos los puntos marcados con la línea roja serán equivalentes porque están conectados entre sí, y
lo mismo ocurre con los puntos marcados con la línea azul. Además, buses están aislados eléctricamente
uno del otro.
 placa de prototipado (breadboard o protoboard)

Por otro lado, en la parte central aparecen un gran cantidad de agujeros. Se usan para colocar y conectar
los componentes. Las conexiones internas están dispuestas de forma vertical, de forma que los agujeros
son completamente equivalentes si pertenecen a la misma vertical. Al conjunto de todos los agujeros
equivalentes conectados entre sí se les denomina nodo.

Finalmente, detectamos una zona central, la que separa la parte superior de la inferior. Se suele utilizar
para colocar los circuitos integrados, de forma que la mitad de un chip está aislada de la otra.

conexiones internas

EJEMPLO
Conectar un LED y ponerlo en funcionamiento de forma intermitente
Para hacer este sencillo circuito, necesitaremos:
-          Placa breadboard
-          1 resistencia 220
-          LED
-          Cables

Puede realizarse de varias formas. La más fácil sin duda es, teniendo en cuenta que el pin 13 ya lleva
incorporado la resistencia del valor que necesitamos, conectar el el LED directamente en dicho pin y en la
GND (tierra), quedando de la siguiente forma.
 patilla más larga en el pin 13

Haciéndolo un poquito más complicado y así entender las conexiones, vamos a conectarlo al pin 12. Se
puede observar en la imagen siguiente que hemos utilizado una resistencia que se encuentra en serie con
el LED. Hay que tener en cuenta que el circuito debe cerrarse, sino no funcionará.

Tal y como hemos explicado antes en cuanto al funcionamiento del LED y de la placa breadboard,
entendemos pues el hecho de que aparezca una resistencia conectada en serie al LED. Siguiendo el
orden de: cable rojo (normalmente usado para la parte positiva), cable verde, resistencia, LED, cable
blanco, cable negro (usado para la parte negativa), tenemos el circuito cerrado, garantizando que, al
menos, circule intensidad por él.

Este es un ejemplo de dominio público que se encuentra en la página oficial de arduino

(http://www.arduino.cc/).

El sketch para este ejemplo (con el pin12) será el siguiente:

// Le damos un nombre al pin 12, concretamente led

int led = 12;
void setup() {               
  // determinamos que nuestra variable led será de salida
  pinMode(led, OUTPUT);    
}

// escribimos el sketch
void loop() {
  digitalWrite(led, HIGH);   // enciende el LED (HIGH)
  delay(1000);               // espera durante un segundo (las unidades son milisegundos)
  digitalWrite(led, LOW);    // apaga el LED haciendo nula la tensión
  delay(1000);               // espera de nuevo un segundo
}
Pulsador. Introducción y ejemplos
Partiendo de la definición de interruptor como un dispositivo que cuando se encuentra “cerrado” deja pasar
la corriente y cuando está “abierto” impide el paso de la misma, un pulsador no es más que un tipo de
interruptor, el cual se mantendrá en posición de “cerrado” tanto tiempo como pulsado lo mantengamos,
gracias a la lámina conductora que produce el contacto.

El circuito estará abierto cuando el pulsador no esté presionado, de forma que al apretarlo, se cerrará el
circuito, haciendo que pase la corriente a través de él.

De acuerdo con las imágenes, puede parecer que el pulsador tiene 4 terminales, pero lo cierto es que las
dos patillas que se encuentran enfrentadas de cada lado están unidas internamente entre sí, lo que
supone que en realidad tengamos solamente dos.

EJEMPLOS
Para controlar un LED mediante un pulsador, no es necesario programar nada, ya que conectamos 5V de
entrada con masa (GND), como si estuviera conectado a una pila.
 Los cables rojo y negro indican el ánodo y el cátodo, respectivamente, haciendo el comportamiento como el de un circuito eléctrico corriente. 

Caso 1

Unimos el terminal de entrada y el de salida de la parte de la izquierda (o de la derecha), de forma que se

queda unido mediante la lámina conductora.

Con esto conseguimos que el circuito esté siempre cerrado (encendiéndose el LED), comportándose el
pulsador como un cable, es decir, sin poder actuar de ninguna forma.

Caso 2

Cuando unimos el terminal de la izquierda con el de la derecha (o al revés), independientemente de si sea

el de "arriba" o "abajo" (se verá más claramente en el vídeo), entonces el pulsador sí que actúa como un
interruptor. Mientras no esté pulsado, el circuito estará abierto y por tanto el LED permanecerá apagado. El
momento en el que pulsemos, entonces se cerrará el circuito encendiéndose finalmente el LED.

Puede observarse en el vídeo que dependiendo de cómo conectemos los cables blancos, estaremos en el
Caso 1 o en el Caso 2.

Control del encendido y apagado de un LED con dos pulsadores

Para poder realizar este circuito, es necesario que dispongamos de 2 resistencias de 1 kΩ cada una, para
utilizar en el pulsador.

Vamos a ver cómo sería el montaje:

Primero conectaríamos los dos pulsadores, cada uno de ellos unido a un pin (2 y 10 en nuestro caso). En
la misma patilla donde hemos puesto los cables (rojos) colocamos las resistencias unidas a masa
(horizontal de arriba de color azul), para evitar que se nos quemen los pulsadores. Y, con el cable negro,
conectamos dicha horizontal con la masa de nuestro Arduino (GND).

Unimos ahora el cable de alimentación, que distribuirá la tensión en ambos pulsadores, a la otra patilla que
queda libre.

Del Pin de 5V se puede observar en la imagen siguiente cómo une ambos pulsadores (cables naranja)
Finalmente, faltará colocar el LED como hemos explicado en una entrada anterior (Diodo LED.
Introducción y ejemplo ). Lo haremos mediante el pin 13, quedando finalmente el montaje que se muestra
a continuación:

Una vez tenemos el montaje, bastará con introducir un sencillo sketch para hacer que funcione
correctamente:

int LED = 13; //LED

int pulsador1 = 2; // primer pulsador
int pulsador2 = 10; // segundo pulsador

void setup () { 
  pinMode (LED, OUTPUT); //configurado como salida
  pinMode (pulsador1,INPUT); //configurado de entrada
  pinMode (pulsador2, INPUT);
}

void loop () {
  if (digitalRead(pulsador1) == HIGH){ //si el pulsador1 está en alto
    digitalWrite (LED, HIGH); //encender el LED
 }
  else if (digitalRead(pulsador2) == HIGH){ //si el pulsador2 está en alto
    digitalWrite (LED, LOW); // apagar el LED
 }
}
Tutorial - Led RGB con pulsadores

El objetivo de este tutorial consiste en combinar la utilización de pulsadores para controlar el color de un led RGB.

 El modelo RGB se basa en la posibilidad de representar un color mediante la mezcla por adición de los tres colores de
luz primarios: rojo, verde y azul.

Antes de adentrarnos en el montaje, enumeraremos los componentes necesarios para realizar el experimento:

 1 led RGB
 3 resistencias de 270 ohmios (Con 220 ohmios será suficiente, la única diferencia que encontraremos es que a
menor resistencia, el led brillará con mayor intensidad, soportando con garantías este incremento)
 3 pulsadores táctiles
 1 placa breadboard
 1 microprocesador Arduino UNO
 Cables
 1 placa breadboard pequeña adicional (opcional)

A continuación, vemos el diagrama del cableado:

Deberemos comprobar que la patilla más larga del led RGB sea la que esté conectada a tierra. En nuestro diagrama se
trata de la segunda patilla, pero esto puede variar según el tipo de led RGB que tengamos.

Por ejemplo, en el montaje del vídeo que podéis ver al final del tutorial, se ha empleado un led RGB en el que las
patillas "Red", "Green" y "Blue" se disponen de forma sucesiva, y la última patilla comenzando desde la izquierda es
la que se conecta a tierra.

En el de la imagen que veis a la derecha, la disposición es diferente. Por tanto, se deberá tener en cuenta en cada caso
para una correcta conexión de los pines.

Cabe destacar que se está asumiendo que se dispone de un led "Cátodo común". Si, en cambio, nuestro led es "Ánodo
común", deberemos conectar el pin más largo de éste a +5V en vez de a tierra. En este caso, el ciclo de color será
inverso, es decir, cuando accionemos el pulsador dispuesto a encender la luz roja, se encenderá la azul y viceversa.
Tal y como vemos en el diagrama, se está empleando la mitad de la placa breadboard, ya que la parte
media de los buses de nuestra placa está separada, por lo que la corriente no tiene continuidad.
Finalmente, vamos a explicar con detalle el programa a introducir en el software de Arduino. Iremos
analizando cada parte del código para entender qué se consigue con cada una de ellas.
En primer lugar, el código que vamos a introducir presupone que el led está apagado. Si mantenemos
presionado alguno de los botones, el led se encenderá aumentando gradualmente su intensidad. El botón
de la izquierda encenderá el color rojo, el del centro, el verde y el de la derecha, el azul.
Podremos realizar cualquier combinación con estos tres colores, teniendo en cuenta que a mayor tiempo
de pulsación, obtendremos una mayor intensidad de luz. Si queremos volver a empezar con el led
apagado, basta con darle al botón de reiniciar (botón rojo de la placa Arduino).

Vamos por tanto a analizar el programa a emplear:

Primero, la definición de los pines:
 Tenemos tres pines de salida para controlar el led. Mediante éstos podemos controlar cuánta potencia va
a cada color del led.
Necesitamos tres pines más para los pulsadores, los cuales configuraremos como pines de entrada.

1. int redLEDPin = 11;

2. int greenLEDPin = 10;
3. int blueLEDPin = 9;
4.  
5. int redSwitchPin = 7;
6. int greenSwitchPin = 6;
7. int blueSwitchPin = 5;

Tras la asignación de los pines, declaramos las siguientes variables:

1. int red = 0;
2. int blue = 0;
3. int green = 0;

Las utilizaremos para mantener los valores actuales de la intensidad de cada canal del led y pueden variar
de 0 a 255. Por tanto, si tenemos 'blue' = 0, la parte azul del led estará apagada, mientras que si tenemos
'blue'=255, brillará con la máxima intensidad.

1. void setup()
2. {
3. pinMode(redLEDPin, OUTPUT);
4. pinMode(greenLEDPin, OUTPUT);
5. pinMode(blueLEDPin, OUTPUT);
6. pinMode(redSwitchPin, INPUT_PULLUP);
7. pinMode(greenSwitchPin, INPUT_PULLUP);
8. pinMode(blueSwitchPin, INPUT_PULLUP);
9. }
10.  
11. void loop()
12. {
13. if (digitalRead(redSwitchPin) == LOW)
14. {
15. red ++;
16. if (red > 255) red = 0;
17. }
18. if (digitalRead(greenSwitchPin) == LOW)
19. {
20. green ++;
21. if (green > 255) green = 0;
22. }
23. if (digitalRead(blueSwitchPin) == LOW)
24. {
25. blue ++;
26. if (blue > 255) blue = 0;
27. }

Tras definir el modo de los pines ( 'input' para las entradas y 'output' para las salidas), pasamos a la parte
de los bucles. Cada uno de ellos funciona de la misma manera. 
Por ejemplo, el primero controla el led rojo. Si 'digitalRead', mediante 'redSwitchPin' detecta que está en
'LOW', lo que quiere decir que el botón está pulsado, se le suma 1 a 'red' (mediante el comando ++). Y
seguirá sumando hasta que 'red' llegue a 255. A partir de este momento, el 'if' siguiente volverá a poner
'red' a 0 y se iniciará de nuevo el bucle.

1. analogWrite(redLEDPin, red);
2. analogWrite(greenLEDPin, green);
3. analogWrite(blueLEDPin, blue);
4. delay(10);
5. }

Con el 'delay' final conseguimos reducir la velocidad de cambio de color del led para que nos sea más fácil
manipularlo.

Y con esto ha sido todo por hoy. Os dejo un vídeo con el correcto funcionamiento del proyecto.
Potenciómetro. Introducción y ejemplos.
Un potenciómetro es una resistencia variable, podemos elegir el valor que puede tomar. De esta forma,
controlamos la intensidad de corriente que fluye por un circuito si éste está conectado en paralelo, así
como la diferencia de potencial si está conectado en serie.

El potenciómetro dispone de tres patillas: entre las dos de sus extremos existe siempre un valor fijo de
resistencia, y entre cualquiera de los dos extremos y la patilla central tenemos una parte de ese valor. Es
decir, la resistencia máxima que ofrece el potenciómetro entre sus dos extremos no es más que la suma
de las resistencias entre un extremo y la patilla central.

símbolo eléctrico

EJEMPLOS

Potenciómetro para encender 5 LEDs

En este ejemplo observaremos que a medida que variamos la resistencia interna del potenciómetro, se
irán encendiendo más o menos LEDs.

Los componentes que vamos a utilizar en este caso serán:

 5 LEDs (el color no es significativo)

 5 resistencias de 220Ω (una para cada LED)
 1 potenciómetro 50kΩ

Primero, procederemos a montar el circuito en la breadboard. Antes que nada, conectaremos el

potenciómetro: la patilla de la derecha, la conectaremos a la alimentación de 5V (cable rojo), la patilla
central la conectaremos al pin analógico A0 (cable amarillo), y finalmente, el cable blanco irá conectado a
masa, quedando el siguiente resultado:
 conexiones del potenciómetro
Una vez tenemos esta parte hecha, procedemos a conectar los LEDs. Hay que tener en cuenta, como se
ha explicado en una entrada anterior (Diodo LED. Introducción y ejemplo), que para cada diodo LED, es
necesario conectar una resistencia de 220Ω para evitar que éste pueda ser dañado.

Así, como tenemso 5 LEDs, utilizaremos 5 pines distintos (2, 3, 4, 5 y 6). Seguidamente irá conectada una
resistencia (cables azules) y a continuacion el LED. Para terminar, la salida del LED debemos conectarla a
masa, para así garantizar que el circuito esté cerrado (cable naranja).

El resultado final sería el siguiente:

Una vez realizado el montaje, pasamos a escribir el código para poder mandarle la información a nuestro
arduino.
int leds[]={2,3,4,5,6};  // simplificación a la hora de definir las variables. Está definiendo los 5 pines.
int pot;  // Esta variable se refiere al potenciómetro
int n=0; // Variable auxiliar que utilizaremos como contador en el bucle.
void setup(){
    for(n=0;n<5;n++)
 {
  pinMode(leds[n],OUTPUT);
 }
  Serial.begin(9600);   //Iniciamos la comunicación con el puerto monitor serial
}

void loop(){
  pot = analogRead(0);// Definimos el valor de la variable pot como una analógica en el puerto A0

/*Monitorizamos el valor del potenciómetro con el serial.print seguido entre paréntesis de lo que queremos que nos
muestre.*/
  Serial.print("Valor del potenciometro: ");
  Serial.print(pot);
  Serial.print("\n");
  delay(2000);
  
/*Ahora definimos los límites de acuerdo con los valores que va obteniendo el potenciómetro, para determinar a partir
de qué valor se encenderá cada LED*/

  if(pot >= 0 && pot <= 150){  //Definimos el rango para el cual se encenderá el LED
  for(n=0;n<1;n++)   //solo se enciende un LED, de ahí el número 1
  digitalWrite(leds[n],HIGH); // Se encienden n LEDs, aquí n = 1
  for(n=1;n<5;n++)  //Los demás LEDs están apagados
  digitalWrite(leds[n],LOW);
  } 

//Para los demás bucles se procederá de la misma forma, modificando las condiciones de encendido

  if(pot >= 150 && pot <= 300){

  for(n=0;n<2;n++) 
  digitalWrite(leds[n],HIGH);
  for(n=2;n<5;n++)
  digitalWrite(leds[n],LOW);
  } 
  if(pot >= 300 && pot <= 450){
  for(n=0;n<3;n++) 
  digitalWrite(leds[n],HIGH);
  for(n=3;n<5;n++)
  digitalWrite(leds[n],LOW);
  } 
  if(pot >= 450 && pot <= 600){
  for(n=0;n<4;n++) 
  digitalWrite(leds[n],HIGH);
  for(n=4;n<5;n++)
  digitalWrite(leds[n],LOW);
  } 
  if(pot >= 600){
  for(n=0;n<5;n++) 
  digitalWrite(leds[n],HIGH);
 }
 }

Para finalizar con el ejemplo, mostramos un vídeo del funcionamiento, y otro vídeo de la monitorización.