Hace ya algún tiempo mi amigo Rubén, apasionado de los Playmobil, me sugirió la idea de hacer que sus «imitaciones» de lámpara que ya tiene lucieran.
Pero el objetivo no era que diesen una luz estática, si no que al iluminar una casa, una catedral o cualquier lugar en el que se instalará la lámpara, se simulara que estas llamas eran de fuego.
Ya existen en el mercado soluciones para esto:
Pero el problema es que son muy voluminosas, o se calientan mucho o funcionan a 220V. Y cualquiera de las tres cosas no nos molan para el Playmobil. Además, el poner estas bombillas quitarían el «espíritu Play» y sería un custom demasiado custom. Vamos, que yo quería que siguiera siendo Playmobil.
También Playmobil tiene algo parecido, que es una luz que viene en el belén 4884, pero es un poco grande y la luz que da es un poco fea.
El efecto fuego de estas lamparas para belenes deja mucho que desear. Es un efecto fuego demasiado “ortopédico”. El fuego real es aleatorio, por lo que si quería un efecto fuego real tenía que irme a luces con encendido y apagado aleatorio.
En algunos foros ya se planteaba esto de poner luces a cosas de Play, y fue de donde saqué la idea, pero estaban orientados a luces fijas. Consiste en coger las antorchas, tomar las llamas, hacerles un agujero y ponerles un led de 3mm. Problema, seguia siendo muy grande…
Objetivos del proyecto.
Objetivo 1: utilizar Playmobil (por lo menos la parte que se va a ver)
Al final, me decanté por coger las llamas que vienen con las antorchas con la referencia 30 23 0392 y el candelabro de techo que viene en el castillo 3268 que lleva para cinco llamas con referencia 30 24 7900.
Objetivo 2: que luzca
Facil: utilizar diodos LED que ocupan poco, se calientan nada y consumen menos.
Objetivo 3: Que tenga efecto fuego
Esto ya es de nivel. Por mis conocimientos de electrónica, lo más facil para mí es utilizar un microcontrolador (vulgo «chip») que apague y encienda las cinco luces de manera aleatoria. Me decanté por un chip de 8 patas superpequeño y le programé un algoritmo generador de números aleatorios.
Montaje
Al final, con todas las piezas de Play ya identificadas, procedí al montaje.
Lo primero es vaciar las llamas. Con la Dremel y una broca fina se hace un agujerillo en los mangos de las llamas. Por este agujero tienen que pasar los dos cables para el led. Después, con una fresa fina (o broca) y paciencia vaciamos la llama de material para que luzca con más intensidad cuando el led que lleve dentro esté encendido.
En la foto muestro ya la llama sin el mango, vaciada y ya con los cables y el LED. He utilizado un LED de color blanco de alta intensidad y en formato SMD, esto es, sin patas. Como se puede apreciar, el grado de miniaturizacion es elevado y obliga a utilizar hilo esmaltado y tener maña con el soldador.
Para hacerse con estos leds, solo hay que ir a algún proveedor oriental, tipo DealExtreme, y buscar en las secciones de DIY (Do It Yourself). Si no quereis usar SMD, se pueden usar otros leds más granes, como de 2mm o 2.5mm, pero habrá que remodelar bastante para que quepan.
Antes de pegar con pegamento la llama con su mango, hay que asegurarse que el led funciona. Para ello utilizad un tester en la posicion de comprobación de diodos y ver que lucen. NO PONERLO DIRECTAMENTE A UNA PILA, PUES SE DESTRUIRÁ.
En la foto se ven las cinco llamas ya preparadas, una de ellas todavía con el mango sin pegar. En el candelabro, he puesto un clip que asoma por la parte superior en forma de argolla y así poder ponerle una cadena una cuerdecita para colgar el candelabro del techo.
Lo siguiente es hacer un agujerillo del mismo diametro que el hecho en los mangos de las llamas para pasar los cables por los brazos del candelabro. En la foto de arriba se ve el candelabro que lleva un agujerillo al final de cada brazo que lleva hasta el alojamiento de la llama.
Los cables son muy finos y podrán ir escamoteados por mitad del brazo, como se ve en la foto de encima.
Al final todos los cables tienen que ir al centro del candelabro, donde hay espacio muy justo para poner toda la electronica (el chip de control y el de alimentación).
Electrónica
Aquí ya entramos en terreno desconocido para algunos pero para otros no. No me voy a parar a hacer una masterclass de programación de microcontroladores ni de electrónica. Ya hay mucha literatura al respecto y a ella os remito.
Para el control, he utilizado un microcontrolador Microchip PIC12F683 de 8 patas en encapsulado SMD SOP-8.
Dicho microcontrolador tiene cinco salidas que pueden manejar los cinco leds que tenemos. Lo unico «extra» que se necesita es cinco resistencias y un regulador de tensión para olvidarnos de si ponemos la tensión correcta o no (en la foto es el componente de tres patas, un 78L05).
El esquema electrico lo pongo aqui:
Al tener un espacio superreducido, no he puesto ni condensadores ni nada más, y las resistencias van soldadas directamente en las patas del microcontrolador. Un par de cables, uno rojo y otro negro, salen por la parte superior del candelabro para llegar al techo de la estancia y allí poder conectarlo bien a una fuente externa o una pila de 9V, por ejemplo.
En conclusión, visto desde fuera lo unico que desentona es el cable que sale:
Programación
Para que el montaje funcione, es necesario programar el microcontrolador para decirle que encienda las «lámparas» con un efecto similar al fuego. Para ello, lo que he hecho es generar números pseudoaleatorios.
De esta forma, cada una de la lámparas se va encendiendo a un nivel de luminosidad aleatorio (para los que saben de electronica, por PWM). El tiempo entre cambios de nivel es aleatorio también. Y ya para rizar el rizo, el número de lámparas que cambian la luminosidad cada vez también es aleatorio.
Por ello, dado el alto número de combinaciones aleatorias que se pueden dar, el efecto es bastante caótico y será altamente improbable que se repita la secuencia de luces como para que nos demos cuenta, con lo que se consigue un efecto muy cercano a un fuego.
Os dejo el código fuente, en lenguaje C para compilar en algún compilador para Microchip como por ejemplo CCS:
FuegoLed.c
[cpp classname=»codigo»]
#include "FuegoLed.h
#include <STDLIB.H>
#define PASOS_PWM 100
#define RAND_MAX 100
#define MIN_PWM 20
#define MAX_TIEMPO 50
// Varibales globales
char semilla,semilla_old;
unsigned int32 superSemilla;
void CalcularNuevaSemilla(void)
{
//nueva semilla aleatoria
;semilla = get_rtcc();
if(semilla_old == semilla)
semilla++;
superSemilla += (unsigned int32)semilla;
srand(superSemilla);
semilla_old = semilla;
}
char NuevoValorLLama(void)
{
char pwm;pwm=(char)rand();
// Evito los valores bajos y los cambio por altos para mayor luminosidad
if(pwm < MIN_PWM)
pwm += (PASOS_PWM-MIN_PWM);return (pwm);
}
void main()
{
char step, pwm1,pwm2,pwm3,pwm4,pwm5,maskCambio;
char tiempoPWM;setup_adc_ports(NO_ANALOGS|VSS_VDD);
setup_adc(ADC_OFF);setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
setup_timer_1(T1_DISABLED);
setup_timer_2(T2_DISABLED,0,1);
setup_comparator(NC_NC);
setup_vref(FALSE);
setup_oscillator(OSC_8MHZ);step=PASOS_PWM;
tiempoPWM = 250;
// Valores de duty cycle
pwm1=90;
pwm2=80;
pwm3=30;
pwm4=25;
pwm5=10;
superSemilla = (unsigned int32)get_rtcc();
while(1)
{
do
{
do
{
if(pwm1>=step) output_high(PIN_A0); else output_low(PIN_A0);
if(pwm2>=step) output_high(PIN_A1); else output_low(PIN_A1);
if(pwm3>=step) output_high(PIN_A2); else output_low(PIN_A2);
if(pwm4>=step) output_high(PIN_A4); else output_low(PIN_A4);
if(pwm5>=step) output_high(PIN_A5); else output_low(PIN_A5);
step–; //incrementar paso
}
while(step>0);
step=PASOS_PWM;
tiempoPWM–;
}
while(tiempoPWM>0);
//nueva semilla aleatoria
CalcularNuevaSemilla();
// Cambiar el tiempo de salida de valores
tiempoPWM = (char)rand();
tiempoPWM = tiempoPWM>>1;
// Cambiar los valores de duty
CalcularNuevaSemilla();
// No cambian todos a la vez
maskCambio=(char)rand();
// Valores de llama
if(maskCambio & 0x01)
pwm1=NuevoValorLLama();
if(maskCambio & 0x02)
pwm2=NuevoValorLLama();
if(maskCambio & 0x04)
pwm3=NuevoValorLLama();
if(maskCambio & 0x08)
pwm4=NuevoValorLLama();
if(maskCambio & 0x10)
pwm5=NuevoValorLLama();
}
}
[/cpp]
FuegoLed.h
[cpp classname=»codigo»]
#include <12F683.h>
#device adc=8
#FUSES NOWDT //No Watch Dog Timer
#FUSES INTRC_IO //Internal RC Osc
#FUSES NOCPD //No EE protection
#FUSES NOPROTECT //Code not protected from reading
#FUSES MCLR //Master Clear pin enabled
#FUSES NOPUT //No Power Up Timer
#FUSES NOBROWNOUT //No brownout reset
#FUSES IESO //Internal External Switch Over mode enabled
#FUSES FCMEN //Fail-safe clock monitor enabled
#use delay(clock=8000000,RESTART_WDT)
[/cpp]
Resultado
Y ya para finalizar, vemos el resultado con unos videos:
Buenas. Quería preguntarte una cosa.
No acao de entender lo de PWM. Los leds están conectados a pines de salida, no? Pero para que fluctuen significa que reciben diferentes valores entre Vref+ y Vref- no? Como se consigue eso con un solo PWM? No estaría eso afectando a la corriente de entrada del micro?
Gracias! 😀
Hola Lissie
Como bien dices, los leds estan puestos a pines de salida. Este micro no tiene conversores digital-anaologico (DAC), por lo que no se genera una señal analogica pura, sino una señal cuadrada modulando el duty cycle. Lo que es lo mismo, PWM (http://es.wikipedia.org/wiki/Modulaci%C3%B3n_por_ancho_de_pulsos)
Por tanto, en este caso, Vref- y Vref+ no tienen ningún sentido.
Las salidas pueden valer 0V ó 5V a una frecuencia tal que no se note a la vista (no recuerdo cuanto puse, pero por encima de 40 Hz). Con el PWM, si el duty es de 50% pues al led le estas aplicando realmente 2,5V. Si el duty cycle es 80%, al led le estas aplicando 4V.
Lo que hace el programa para emular la fluctuacion es poner diferentes valores de Duty cycle aleatorios para cada salida durante un tiempo tambien aleatorio.
El programa no utiliza las librerias de PWM que el compilador trae para este micro, sino que lo que se hace es hacer un bucle que tarda un tiempo fijo y en cada ejecución del bucle mirar a ver, según el duty cylce de cada salida, si hay que activarla o desactivarla. Es como tener cinco PWMs diferentes. Como el micro no tiene que hacer otra cosa nos podemos permitir el lujo de tenerlo dedicado exclusivamente al bucle del PWM.
Por supuesto la corriente de entrada del micro es la que tiene que alimentar a los cinco leds, por lo que estará fluctuando igual que los leds.
No sé si habré despejado tu duda. Si no es así, no dudes en seguir preguntando.
Saludos
Estimado falconhunter,
Estudiando alternativas a la clásica bombilla efecto fuego para mi portal de belén he llegado a tu magnífico post sobre la lámpara de antorchas Playmobil.
Enhorabuena, además de ingenioso y bien ejecutado es artístico.
He leído que bromeabas con hacerlos en serie… No me parece ninguna tontería… No dispongo de herramientas ni conocimiento en la programación de microcontroladores, y tampoco tengo tiempo de aprender, el belén ya está puesto!
No necesito más que el micro programado, gracias a tu esquema me resultará sencillo montar el resto…
¿Serías capaz de venderme 3 chips ya programados? ¿Por cuanto?
Digo 3 chips por si jodo alguno en el intento! Jajaja
Y ya puestos, los leds SMD, que no sé si los encontraré… 10 leds como los que pusiste serían suficientes.
Espero que sea posible, a mis niños le hará mucha ilusión.
Hola
Donde conseguisteis el candelabro
Podria comprar xips ya programados a ustedes?
El candelabro y las llamas las pedí al DS. Es un servicio de Playmobil para piezas sueltas y referencias que no hay en tiendas.
Aquí te dejo una referencia de como se usa este servicio:
http://www.aesclick.com/public/joomla/index.php?option=com_content&view=article&id=259&Itemid=66
Las referencias a conseguir son:
Llamas: 30 23 0392
Candelabro: 30 24 7900
Podría facilitarte algunos chips programados. Te respondo a ello por privado.
Buenas tardes,
se puso finalmente en contacto contigo? te pudo facilitar los chips?
Hola!! me ha encantado este tutorial, pero no se por donde cogerlo… 🙁
Cuando copio tu código fuente, me salta el error 128 en la libreria stdlib.h :S
¿Puedes ayudarme?? creo que le configuro bien el pic pero no me compila bien… 🙁
¿donde esta el fallo? ¿puedes pasarme el .hex? 😀 aunq preferiría q me ayudaras con el error a ver si aprendo a programar pics.
Gracias y un saludoo
Hola
Gracias a tu comentario me he dado cuanta que faltaban los includes.
El error 128 suele pasar porque falta algún #device. En este caso, las definiciones de #device están en el fichero FuegoLed.h.
Claro, que para ello en el fichero .c hay que indicarle que incluya el fichero de header.
He actualizado el código. Bastaría con incluir:
– la línea #include «FuegoLed.h en el fichero FuegoLed.c
– la línea #include <12F683.h> en el fichero FuegoLed.h <-- Este modelo de PIC u otro a utilizar Prueba a ver si ahora te compila. En cualquier caso te puedo pasar el .hex. Saludos
hola podías hacerme el favor de pasarme el hex para poderlo compilar al pic?
Te felicito, éste si que es un trabajo bien hecho.
Muchas gracias.
Diego
Hola, me gustaría saber si podrias venderme un chio programado.
Hola
Te repondo por privado
Saludos y gracias
Buenos días,
recupero después de unos «pocos años» el tema, que por otra parte está muy bien abordado…
quería que me suministraras los chips para el belén. pero la diferencia es que quiero usar lamparitas de 3v 0.03mA. sería posible?
gracias y un saludo
me podrías facilitar chips programados? GRACIAS
Hola buenas tardes sería posible que me facilites el fichero HEX para grabarlo directamente al pic en cuestión
Muchas Gracias por tus aportaciones
Magnifico post. Intentaré programar el pic para el Belén de este año. Muchas gracias por tu aporte. Fer.