Volvemos con los proyectos y sobretodo con este que lo teníamos un poco abandonado por no decir mucho, la verdad que en todo este tiempo siempre le hemos estado dando vueltas al tema de la lampara en como hacerla, la electronica que llevaría y demás y como queríamos probar Arduino pues decidimos que iria controlada con Arduino lo cual nos a facilitado mucho no muchísimo el trabajo, eso si el aprender a manejarlo nos a llevado un poco de tiempo.
Este sera nuestro cerebro un Arduino UNO la placa mas sencilla de las Arduino pero que nos sirve perfectamente para lo que queremos hacer, aunque en el montaje final no usaremos la placa completa si no que montaremos solo el Atmega para no desperdiciar la placa y poder seguir desarrollando futuros proyectos.
La lampara tendra las siguientes funciones:
Mediante el pulsador 1 seleccionaremos los siguientes programas:
- Modo manual, podremos seleccionar el color deseado dejando lo fijo mediante 3 potenciometros uno para cada color.
- Modo automatico, cambaria de color solo en un ciclo que intentaremos que dure 1 hora aprox.
Mediante el pulsador 2 encenderemos y apagaremos la " luz de techo" que serán 20 LEDs blancos de 10mm para poder hacer la función de lampara de pie y ademas se podrá regular con un cuarto pulsador.
La lista de componentes en un primer momento queda así, puede que añadamos alguna cosa en próximas entradas pero se comentaran:
1 x Arduino (en principio el código que os ofreceremos esta echo para una UNO pero podeis usar la que queráis adaptando si es necesario el código)
1 x LED azul 3mm
2 x LED amarillo 3mm
1 x LED blanco 3mm
40 x LED RGB de Anodo común (positivo)
20 x LED blanco 10mm
4 x potenciometro de 10k
6 x Resistencia ceramica de 24 ohmios y 6w
4 x resistencias 220 ohmios 1/4w
2 x resistencias 10k
2 x pulsador n.o.
2 x ULN2803
2 x zocalos para los ULN (18 patillas)
Pines para circuito impreso
Clemas de circuito impreso
cables varios.
Placa protoboard de agujeros.
Una fuente de alimetacion de 12V y minimo 3A (36w), nostros vamos a usar una de 8A (160w)
Al principio tenia todo mas o menos claro pero no sabia exactamente como manejar tal cantidad de LED hasta que di con la pagina de Ledfacil y vi su propuesta para manejar los LEDs RGB de forma analogica con potenciometros usando un ULN para poder entregar la potencia necesaria y en el cual nos vamos a basar en parte:
Como veis con este circuito se pueden manejar hasta 40 LEDs RGB que es para lo que esta calculado el circuito, nosotros lo que hemos hecho a sido sustituir la parte de los potenciometros por la placa de Aduino. Ahora quedaba lo mas difil de todo aprender un poco de Arduino para poder hacer funcionar todo como esperamos y nos pusimos manos a la obra y dimos con esta pagina, mbeckler, de la cual sacamos el codigo para el loop del RGB y el control manual RGB, ahora que teníamos mas o menos claro esto empezamos a dilucidar como queríamos el control y el como saltar de un programa a otro.
Luego tambien tuvimos que pensar en la parte de los LEDs blancos aunque fue facil porque usaremos el mismo circuito de antes pero adaptado para una unica salida así que echamos mano de Fritzing, que ya os hablaremos de este programa el cual me parece simplemente genial, y quedo algo como esto:
Menudo lio de cables ehh?, pues cuando veáis la placa montada no os digo nada, los ULN van controlados mediante las salidas PWM de Arduino y los LEDs que indican el estado y el programa seleccionado van conectados en los pines digitales, los pulsadores y los potenciometros iran conectados en los pines analógicos quedando así distribuido:
Pines digitales:
- Pin2 = LED Azul.
- Pin4 = LED Amarillo1.
- Pin7 = LED Amarillo2.
- Pin8 = LED Blanco.
- PWM3 = LEDs Blancos.
- PWM9 = Pin rojo de los LEDs RGB.
- PWM10 = Pin verde de los LEDs RGB.
- PWM11 = Pin azul de los LEDs RGB.
Pines analógicos:
- A0 = pulsador 1 que sera el encargado de cambiar los programas de RGB.
- A1 = Potenciometro para controlar el color rojo.
- A2 = Potenciometro para controlar el color verde.
- A3 = Potenciometro para controlar el color azul.
- A4 = Potenciometro para controlar los leds blancos.
- A5 = Pulsador 2 que sera el encargado de encender y apagar los LEDs blancos.
Las salidas PWM no iran conectadas a los LED RGB sino que pasaran a sustituir a la parte de los potenciometros del diseño de LedFacil.
Lo primero que vamos a montar va a ser la placa de "potencia" de los LED RGB, soldaremos uno de los ULN y las 6 resistencias, el circuito original esta dividido en dos partes por así decirlo van puenteadas las patillas 1 y 4, 2 y 5, 3 y 6, siendo 1 el canal rojo, 2 el verde y 3 el azul. pudiendo manejar hasta 20 LED RGB en cada salida.
Las resistencias del circuito original son de 22 ohmios pero las únicas que pudimos conseguir eran de 24 ohmios y 6W:
La ventaja es que son resistencia fusible y si tenemos algún sobre consumo en alguno de los canales tendremos protección extra así que nos ponemos manos a la obra y nos quedo una cosa como esta:
Como podeis ver tenemos en la parte central de izquierda a derecha las siguientes conexiones:
1 Canal rojo.
2 Canal verde.
3 Cana azul.
4 No conectado.
5 Negativo
6 Positivo a 12V
El primer grupo de la izquierda son por orden de izquierda a derecha:
1 Canal azul.
2 Canal verde.
3 Canal rojo.
4 Positivo a 12V.
El ultimo grupo de la derecha:
1 Positivo.
2 Canal rojo.
3 Canal verde.
4 Canal azul.
Esta es la cara de las soldaduras:
Ahora vamos a montar el segundo ULN que sera el encargado de manejar los 20 LEDs blancos:
Esta vez usaremos una placa mas pequeña por que los leds que tenemos ya viene preparados para 12v asi que nos ponemos manos a la obra, para no pillarnos los dedos y poder poner mas LED si lo necesitásemos hemos puenteado las entradas de la 1 a la 6 y las salidas correspondientes y pondremos unas clemas de circuito impreso:
Tambien pondremos unos pines a traves de los cuales pasaremos la corriente para alimentar el ULN y los LEDs:
Los pines que quedan a la derecha en la primera imagen son los de los 12v y los de la izquierda los del negativo y las clemas son la de la derecha la que irá conectada al pin PWM 3 y los de la derecha el superior el negativo y el inferior el positivo y así quedaria montado en la placa de los LED RGB:
Con esto tenemos la parte que dará corriente a todos los LEDs, ahora vamos a montar la parte de los pulsadores, nostros hemos optado por separar el pulsador que controlara la parte de RGB con sus LED y la del blanco con su LED:
En Arduino es aconsejable poner una resistencia de pulldown en los pulsadores para evitar poder dañar la placa:
+23.09.32.png) |
| Ejemplo de conexión de el pulsador y la resistencia |
Así que necesitaremos lo siguiente:
- Los LEDs de 3mm, azul, y 2 amarillos.
- 3 resistencias de 220 ohmios.
- 1 resistencia de 10k ohmios.
- 1 pulsador.
Cara de las soldaduras:
Ahora hacemos lo mismo con el segundo pulsador necesitaremos lo siguiente para este otro pulsador:
- 1 LED blanco.
- 1 resistencia de 10k ohmios.
- 1 resistencia de 220 ohmios.
- 1 pulsador.
Cara de soldaduras:
Para poder conectar toda la ingente cantidad de cables al Arduino hemos echo una especie de placa shield para poder conectar todos los cables.
Ahora ya podemos soldar todos los cables a las patillas que correspondan, ahora toca el turno a los potenciometros:
Los marcamos para saver cual es cada uno:
La conexión de los potenciometros a la placa de Arduino se hace de la siguiente manera:
+23.30.20.png)
 |
| Bonito lio de cables en la parte de la shield. |
Lo primero fue coger y cortar una tira que nos sirviera para lo que queremos hacer:
Y después de medir mas o menos nos liamos a poner los LEDs:
El problema viene en que este tipo de montaje habría que hacerlo a doble cara y nos tuvimos que usar unos puentes por la parte superior:
Quedando el apaño así:
La parte de las soldaduras quedo así:
Y las superior así:
Y las conexiones:
Los colores de los cables quedan así:
Amarillo = canal rojo.
Verde = canal verde.
Blanco = canal azul.
Rojo = positivo.
Lo siguiente que toca es la parte de programación de el Arduino y os dejamos el código para cargarlo en el Arduino y que todo funciones como lo hemos diseñado.
 |
| Probando y programando |
Código para el Arduino, el tiempo del ciclo de RGB automatico esta en 10ms lo he dejado bajo adrede si quereis que tarde mas solo tenéis que modificar el valor de delay que se encuentra al final del código:
// Proyecto Lampara de salon
// www.yutris.com
// codigo de RGB manual y auto matico
// extraido de la pagina de Matthew L Beckler
// en www.mbeckler.org
//leds de estado
int led1= 2;
int led2= 4;
int led3= 7;
int led8= 8;
//pulsadores seleccion
int pulPin= A0;
int pulwPin= A5;
int cambia= 0;
int cambiaw= 0;
//pines para rgb y luz blanca
int redPin= 11;
int bluePin= 10;
int greenPin= 9;
int whitePin= 3;
//pines para los potenciometros
int redIn= A1;
int greenIn= A2;
int blueIn= A3;
int whiteIn= A4;
int redVal;
int greenVal;
int blueVal;
int whiteVal;
void setup()
{
pinMode(A0, INPUT);
pinMode(A5, INPUT);
pinMode(2, OUTPUT);
pinMode(4, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
redVal = 255;
greenVal = 255;
blueVal = 255;
whiteVal = 255;
update();
}
void loop(){
if (digitalRead(A5)==HIGH){ //pulsador para luz blanca
cambiaw++;
if (cambiaw>1){
cambiaw=0;
}
while (digitalRead(A5)==HIGH){}
}
if (cambiaw==0){ //apagado luces blancas
modow0();
}
if (cambiaw==1){ // encendido luces blancas y regulacion
modow1();
}
if (digitalRead(A0)==HIGH){ //pulsador modos RGB
cambia++;
if (cambia>2){
cambia=0;
}
while (digitalRead(A0)==HIGH){}
}
if (cambia==0){ // modo standby
modo0();
}
if(cambia==1){
modo1(); //modo manual
}
if(cambia==2){ //modo ciclo auto
modo2();
color_morph(&redVal, 1);
color_morph(&greenVal, 1);
color_morph(&redVal, 0);
color_morph(&blueVal, 1);
color_morph(&redVal, 1);
color_morph(&greenVal, 0);
color_morph(&redVal, 0);
color_morph(&blueVal, 0);
}
}
void modow0(){ //off luces blancas
digitalWrite(led8,LOW);
analogWrite(whitePin, 0);
}
void modow1(){ //on luces blancas
digitalWrite(led8, HIGH);
whiteVal = analogRead(whiteIn);
whiteVal= map(whiteVal, 0, 1023, 0, 255);
analogWrite(whitePin, whiteVal);
}
void modo0(){ //standby rgb
digitalWrite(led3,LOW);
digitalWrite(led1,HIGH);
analogWrite(redPin, 0);
analogWrite(greenPin, 0);
analogWrite(bluePin, 0);
}
void modo1(){ //modo manual rgb
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
redVal = analogRead(redIn);
greenVal= analogRead(greenIn);
blueVal= analogRead(blueIn);
redVal = map(redVal, 0, 1023, 0, 255);
greenVal= map(greenVal, 0, 1023, 0, 255);
blueVal= map(blueVal, 0, 1023, 0, 255);
analogWrite(redPin, redVal);
analogWrite(greenPin, greenVal);
analogWrite(bluePin, blueVal);
}
void modo2(){ //modo auto rgb
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);
}
void update()
{
analogWrite(redPin, redVal);
analogWrite(greenPin, greenVal);
analogWrite(bluePin, blueVal);
}
void color_morph(int* value, int get_brighter)
{
for (int i = 0; i < 255; i++)
{
if (get_brighter)
(*value)--;
else
(*value)++;
update();
if (digitalRead(A0)==HIGH){ //salimos del bucle de rgb y volvemos a standby
modow0();
break;
}
if (digitalRead(A5)==HIGH){ //encendemos y apagamos las luces blancas
cambiaw++;
if (cambiaw>1){
cambiaw=0;
}
while (digitalRead(A5)==HIGH){}
}
if (cambiaw==1){ //encendemos
modow1();
}
if (cambiaw==0){ // apagamos
modow0();
}
delay(10);
delay(10);
}
}
Seguramente se pueda hacer de otra manera la programación, no somos ningunos expertos y estamos aprendiendo, si mejoramos el código se publicara en nuevas entradas
Una vez lo hemos subido a la placa conectamos nuestra shield y nos preparamos para probar:
En este punto del proyecto, ya se que os hemos soltado un buen tocho, podeis usarlo para otros fines simplemente metiendo todo esto en una caja tendríais una controladora de leds para poder iluminar por ejemplo una terraza distribuyendo los LEDs, un salon o un pasillo.
La proxima entrega tardara un poco espero que no tanto como esta pero tenemos que ver como hacemos el pie puesto que la propuesta del principio no me termina de convencer e intentaremos hacer algo mucho mas elegante y moderno.
No hay comentarios:
Publicar un comentario