Horno para soldar PCBs

Llevo un tiempo con este proyecto para el taller: un horno para soldar placas. No he querido hacer varios posts «diarios» comentando las actualizaciones del proyecto, básicamente porque no tenía muy claro qué componentes utilizar, y si podría programar el firmware en un tiempo más o menos razonable.

Al final, ha salido todo mucho más rápido de lo que pensaba, asi que os voy a hacer un resumen del proyecto, y quizás escriba algún artículo sobre algun tema concreto, ya que han salido distintos temas muy interesantes. La idea general es usar un horno normal y corriente, y controlar la temperatura con un arduino. Para ello usaremos una sonda de temperatura para ir tomando la medida, y un relé de estado sólido para encender y apagar las resistencias del horno (Usaremos un relé de estado sólido, porque el relé mecánico se estropearía con el tiempo de tanto on/off).

 

 

El horno lo conseguí de segunda mano en ebay. He probado uno de 1300W, pequeñito, totalmente mecánico (sin electrónica ni circuitos). Estos hornos tienen 2 resistencias, que simplemente están conectadas a la corriente principal. El funcionamiento es bastante simple. Trae un potenciómetro básico para controlar la potencia de las resistencias, y un cronómetro con una campanilla para apagar el horno tras un tiempo. Lo que haremos será, poner el potenciómetro a tope (controlaremos nosotros mismos la potencia), y simplemente desconectamos los dos cables de cronómetro y los conectamos en el relé de estado sólido. El Arduino irá encendiendo y apagando las resistencias (mediante pulsos) controlando la temperatura del interior del horno.

Este es el esquema del circuito de control:

Para alimentar el arduino, he comprado una fuente de 12V para LEDs super económica de 2 Amperios. Realmente con 1A sería suficiente, pero por el precio que tienen, he visto que era la opción más económica. Podrías alimentar al arduino por el conector de 12V, pero no es muy recomendable porque cuando el arduíno envía pulsos al ventilador y relé, la pantalla también parpadea. Lo mejor es usar alimentaciñón externa, y que cada cosa vaya independiente.

 

Sobre el control de la placa, podéis leer mi anterior artículo sobre encoders para entender mejor los detalles de estos dispositivos.

He probado varias pantallas LCDs, y me quedo con las pantallas gráficas de Nokia 5110, que son muy baratas, y puedo hacer una gráfica con la temperatura, etc. Lo malo es que el LCD usa 3.3V, y como el arduino funciona a 5V, hay usar un «conversor de niveles». Yo he usado uno de adafruit, que es bidireccional, pero se podría usar algo más económico unidireccional, ya que esta pantalla no envía los datos de vuelta al arduino. He incluido un pequeño potenciometro para controlar el contraste de la pantalla. Dejaré los detalles del LCD para un futuro artículo.

 

Las salidas del Arduino Uno de 5V, no tienen potencia suficiente para mover el ventilador y activar el relé, así que necesitamos transistores que amplifiquen la corriente. Se puede usar un MOSFET, pero no es necesario tanto. Con unos simple transistores bipolares, tenemos fuerza suficiente para mover el ventilador, y activar el relé.

El esquema del transistor del relé es muy simple. Cuando la base tiene 5V, el transistor se activa y permite pasar los 12V al relé. Una resistencia proteje la base del transistor (los bipolares necesitan resistencias, en los MOSFETs no es necesario). Otra resistencia hace de pulldown para que, en el caso que la señal del arduino quede flotando, la base del transistor se mantenga siempre apagada y la corriente no pase de forma aleatoria.

 

 

El esquema del ventilador es igual, pero incluye un condensador de 10uF , que sumada a los 2.2K de la resistencia, filtra un poco los pulsos que envía el Arduino. De esta forma, los pulsos no son tan bruscos y reducen las vibraciones del ventilador. Ambos transistores no llevan el típico diodo de protección, porque el relé no devuelve energía de vuelta al transistor, y el ventilador tiene su propio circuito de protección en el motor brushless. De todos modos, si no sabes muy bien qué vas a conectar, entonces es aconsejable conectar un diodo flyback que proteja el transistor de voltajes de vuelta.

 

Para medir la temperatura, he usado un thermopcoupler de alta temperatura (aguanta perfectamente hasta 300º). Los thermocouplers dan un voltaje proporcional a la temperatura. El problema es que ese voltaje es muy muy pequeño, millivoltios, asi que hace falta un amplificador para poder leer un valor útil. El amplificador que he escogido tiene 2 salidas: un voltaje para la sonda, y otro para la temperatura ambiente. He incluido un condensador para filtrar el voltaje de la sonda, y evitar «ruido» indeseado al leer la temperatura. El problema es que esto hace que tengamos un «retraso» entre la lectura y la realidad, pero la lectura es más estable.

La otra opción es usar un económico termistor, una resistencia variable que, aplicando un voltaje conocido, serviría para leer la temperatura. El problema es que no funciona muy bien en temperaturas altas, y ya que los componentes pueden llegar a estropearse si nos pasamos, asi que he decido apostar por la sonda, que además, está protegida para aguantar temperaturas muy altas. Quizás escriba otro artículo sobre las sondas, amplificadores usando un opamp, etc.

Ojo, es importante usar algun separador de nylon entre el ventilador y el horno, porque el plástico ABS funde a unos 230º grados y se podría derretir con el calor!!

 

Para depurar, he incluido un buzzer y un LED con un jumper que me permite conectarlo al pin del PWM, o usar otro pin del arduino a modo de depuración, avisos, etc. El código está disponible en github , tal cual lo estoy usando ahora mismo. Seguramente sea muy mejorable, pero es suficiente para usar el horno de forma estable. Soldar mediante reflow tiene varias etapas. Se comienza haciendo un «preheat» hasta que llegamos a los 150º. Luego nos quedamos unos 2 minutos manteniendo la temperatura estable, dónde se activa el flux de la pasta de soldadura. Después metemos un golpe de 220º de 60 segundo para que el estaño se vuelva líquido y los componentes se colocan en su sitio. Posteriormente reducimos la temperatura despacio, para evitar que el estaño enfríe demasiado rápido.

El algoritmo de PID también se merece un artículo propio. Yo he usado el código basandome en la librería PID de arduino, adaptado a C normal (últimamente soy un poco alérgico al C++). PID significa «proporcional, intergral y derivada», y es un algoritmo que nos permite saber cuanta potencia hay que mandar al horno para llegar a la temperatura deseada, de forma más o menos óptima. Durante el horneado, el ventilador se mantiene al mínimo, oscilando aproximadamente entre un 50% y un 30% de velocidad , que permite mover lo mínimo el aire, sin enfriar el interior, pero sin llegar a pararse. De esta forma conseguimos que la temperatura sea uniforme dentro del horno. De todos modos tengo que comenzar a realizar pruebas para ver cómo afecta a la calidad de las soldaduras.

La primera versión del circuito lo pasé a una PCB muy sencilla de una cara, a modo de shield de arduino. He puesto unos pines hembra para conectar la pantalla y el conversor de niveles. Es suficiente para hacer las primeras soldaduras, y probar bien el circuito. Os dejo unas fotos del proceso de la PCB

 

.

 

Ahora queda la parte de cerrar todo de alguna forma, meter la pantalla y la placa dentro, etc. Pero he decidido usar el horno varias veces antes de ponerme  a cortar. Quizás saque una versión nueva de la PCB, con el chip del AVR y de doble capa, y con la pantalla y el encoder por separado. De esta forma es sencillo atornillar esta placa al frontal del horno. Pero eso para más adelante. Estoy a la espera de unas placas y de pasta de soldadura nueva, para realizar los primeros test, y publicar aquí resultados.

Cómo usar un Encoder con un Arduino

Un encoder es muy parecido a un potenciómetro por fuera, pero en realidad son muy distintos. El potenciómetro nos da un valor analógico que tenemos que leer, pero el encoder nos envía información «digital» que vamos leyendo según la ruedecita gira. Un modelo común es el PEC11-4215F-S0024, que nos envía 24 «pulsos» en una vuelta completa.

El encoder tiene 3 patillas para los pulsos, y 2 patillas para el boton principal (si pulsas el eje hacia dentro actua como un pulsador).  Este sería el esquema del encoder. Los puntos rojos es donde conectamos los pines del arduino:

BTN es el pin del Botón. Cuando pulsamos, se conectan los 5V con tierra, y BTN vale 0. El resto del tiempo, se mantiene alto.

Para detectar el giro, la idea es conectar una patilla común a tierra, y las otras dos a 5V (con una resistencia de pull up de por ejemplo, 10k). Según vamos girando, el encoder conecta la patilla A y la patilla B a tierra, con un ligero desfase, efectuando así un pulso, que podremos detectar en nuestro arduino.

Si la patilla A baja antes que la patilla B, vamos en el sentido del reloj, y si la patilla B baja antes, vamos hacia atrás.

Esto es una foto del osciloscopio, mostrando las patillas A y B superpuestas, cuando giramos el encoder:

En «reposo», el encoder tiene las 2 patillas en 1. Al girar, se conecta la patilla A con GND, y el voltaje se pone a 0,  seguimos girando y la patilla B, más o menos a la mitad del pulso toca GND, y ambas se ponen a 0. Segun seguimos girando, la patilla A deja de estar conectada a GND, asi que vuelve a 1, y luego la patilla B, volviendo ambas a 1. La longitud del pulso depende de la velocidad a la que nosotros giramos la ruedecita.

Aqui tenemos 1 pulso del encoder :

Podemos pasar esto a binario, 1 cuando el voltaje está alto, 0, cuando está bajo, tomando los valores en distintos momentos del tiempo:

Esto lo podemos traducir a binario:

O sea, la secuencia seria 3 2 0 1 3. Así que, ¿cómo leer esto, y tener control del encoder?

Yo voy a leer todo en la interrución del timer, a intervalos regulares, a una velocidad constante de 125khz. Lo hago así porque luego voy a comunicarme con otros dispositivos, y asi puedo aprovechar la interrupción más tarde. Asi que 125 veces por milisegundo, voy a leer el estado de las 2 patillas para ver si estamos en un pulso o no.

Pero aqui surge un problema. Si mirais la foto del osciloscopio, vemos que hay unos picos raros:

Esto es debido a que los contactos metálicos producen vibraciones, como minichispazos, cuando se separan, y es posible que durante un tiempo la carga se mantenga saltando (bouncing en inglés). Asi que no nos podemos fiar de una lectura simple. Lo que hacemos generalmente es leer varias veces el valor de las patillas, y ver que no han cambiado en el tiempo. Si tras varias lecturas, por ejemplo 125, o lo que es lo mismo, 1 milisegundo, el valor es el mismo, pues aceptamos esa lectura. Este proceso se denomina «debouncing«.

static volatile uint8_t enc_value;
static volatile uint8_t enc_tests;

# define PINS_READ_ENC PINB
# define PINS_WRITE_ENC PORTB
# define PINS_DDR_ENC DDRB
# define PINS_OFFSET_ENC_A 0
# define PINS_OFFSET_ENC_B 1

void encoder_read (void )
{
// leo las 2 patillas al mismo tiempo. Debeis de conectar las 2 patillas del encoder en el mismo puerto!
const uint8_t input = PINS_READ_ENC;
const uint8_t read = ( BitIsSet ( input , PINS_OFFSET_ENC_B ) << 1 ) |
                     ( BitIsSet ( input , PINS_OFFSET_ENC_A ) << 0 ) ;

if ( read != enc_value )
{
enc_tests = 125; // 1 ms a 125khz
enc_value = read;
return;
}

if (enc_tests > 0)
{
-- enc_tests ;
return;
}

if ( enc_tests == 0 )
{
// comprobamos si estamos en un pulso
}

}

El código es C puro, pero facilmente lo podréis pasar al arduino. Realmente q la interrupción sea de 125Khz no es relevante. 1 ms es suficiente para la mayoria de usos.

¿Cómo saber si estamos o no estamos girando, y la direccion? Aqui muchos tutoriales se lian un poco con la secuencia. Si miramos el osciloscopio, vemos que un pulso lo tenemos cuando ambos pines están a 0. Y el valor previo nos dice si estamos girando hacia un lado o hacia otro. Asi que cuando el valor de los 2 pines sea 0, incrementamos o decrementamos en función de la posición.

Técnicamente necesitaríamos salir del pulso, pero en general estos encoders se usan para mover un cursor en el menú de la pantalla y no tiene sentido conocer los pasos intermedios del giro. Si tuviesemos un encoder para medir la posición de un servo entonces usaríamos otras formas de leer los datos, y seguramente, otro encoder más caro :)

Asi que si recordamos la imagen del osciloscopio, vemos que cuando ambos pines están a 0, o bien el A o bien el B tienen que estar abajo antes. Esto es 01 ó 10 en binario: 1 ó 2 en decimal.

Para incrementar el valor de la posición actual (index), sumamos 1 al contador, pero luego comprobamos que no nos pasamos de los pulsos por vuelta (24 según este modelo de encoder). Asi que sumamos 1 y aplicamos el módulo, para que al llegar a 23+1, volvamos a 0. De este modo index se moverá de 0 a 23.

Para decrementar, en vez de restar 1, damos una vuelta entera, sumando 23 y aplciando el módulo. De esta forma, no tenemos que lidiar con valores negativos, y todo es más sencillo luego.

El bit más alto, el signo, del índice, lo reservo para indicar la dirección de giro. 0 significa al sentido del reloj, 1 al revés.

Al guardar el indice de esta forma, digamos que tenemos una representacion angular del encoder, que representa de 0 a 360 grados (con el valor de 0 a 23), con el signo para decirnos qué dirección tomamos para girar.

static volatile uint8_t enc_value;
static volatile uint8_t enc_tests;
static volatile uint8_t enc_index;
static volatile uint8_t enc_previ;

# define PINS_READ_ENC		PINB
# define PINS_WRITE_ENC		PORTB
# define PINS_DDR_ENC		DDRB
# define PINS_OFFSET_ENC_A		0
# define PINS_OFFSET_ENC_B		1

# define ENC_STEPS			24

# define ENC_INDEX_INC		(enc_index = 0< 0)
	{
		-- enc_tests ;
		return;
	}

	if ( enc_tests == 0 )
	{
		if ( ENC_READ_AB == 0)
		{
		     if ( enc_previ == 1 ) ENC_INDEX_INC ;
		else if ( enc_previ == 2 ) ENC_INDEX_DEC ;
		}
 		enc_previ = ENC_READ_AB ;

	}
}

Tambien podemos incluir aqui el valor del pulsador. Al incluir la rutina de «debounce«, nos ahorramos tambien el tema del ruido, pero eso hace que el pulso sea de al menos 1 ms, que depende de lo rapido que seamos, puede ser o no suficiente. Usamos el bit 6 del index para representar el estado actual del pulsador. El código final quedaría asi:

static volatile uint8_t enc_value;
static volatile uint16_t enc_tests;
static volatile uint8_t enc_index;
static volatile uint8_t enc_previ;

# define PINS_READ_ENC PINB
# define PINS_WRITE_ENC PORTB
# define PINS_DDR_ENC DDRB
# define PINS_OFFSET_ENC_A 0
# define PINS_OFFSET_ENC_B 1
# define PINS_OFFSET_ENC_BTN 2

# define ENC_STEPS 20

# define ENC_INDEX_INC (enc_index = 0<<7 | ( (enc_index & 0x3f) + 1 ) % ENC_STEPS)
# define ENC_INDEX_DEC (enc_index = 1<<7 | ( (enc_index & 0x3f) + (ENC_STEPS-1) ) % ENC_STEPS)

# define ENC_READ_AB (read & 0x03)
# define ENC_READ_BTN (read & 1<<2)

void encoder_read (void )
{
 // sure both reads same time
 const uint8_t input = PINS_READ_ENC;
 const uint8_t read = ( BitIsSet ( input , PINS_OFFSET_ENC_BTN ) << 2 ) | ( BitIsSet ( input , PINS_OFFSET_ENC_B ) << 1 ) | ( BitIsSet ( input , PINS_OFFSET_ENC_A ) << 0 ) ;

 if ( read != enc_value )
 {
 enc_tests = 125; // 1 milliseconds on 125khz timer (PEC11 datasheet max debounce rate)
 enc_value = read;
 return;
 }

 if (enc_tests > 0)
 {
 -- enc_tests ;
 return;
 }

 if ( enc_tests == 0 )
 {
 if ( ENC_READ_AB == 0)
 {
 if ( enc_previ == 1 ) ENC_INDEX_INC ;
 else if ( enc_previ == 2 ) ENC_INDEX_DEC ;
 }
 enc_previ = ENC_READ_AB ;

 if ( ENC_READ_BTN )
 {
 ClearBit (enc_index,6);
 }
 else
 {
 SetBit (enc_index,6);
 }
 }
}

Como ejercicio para el lector, queda poder medir la velocidad de giro, contando los «ticks» que han pasado desde que dejan de estar ambos pines a 1, hasta que vuelven a estar ambos pines a 1. Y si tienes ganas, pasarlo a arduino para que la gente pueda usarlo rápidamente.

Por ahora funciona bien, si giras muy muy rápido puede perder algun paso, sobre todo por el «debouncer», pero no es relevante, ya que personalmente voy a usar el encoder para controlar el menú de una pantalla, y es más que suficiente.

Ahorro de energía usando Wake on LAN en Debian Linux

Vaya, si que hace que no escribía en este blog! y no será porque no tengo cosas nuevas de las que hablar, nuevos proyectos, en desarrollo, etc, pero a veces me vuelvo loco con tanta información que no soy capaz de sintetizar todo junto.

Asi que hoy voy a contar lo que hice para ahorrar un poco en la factura de la luz, que está totalmente disparatada.

Tengo un servidor que uso para la intranet, tengo el programa interno de gestion, wiki, y es donde programo cosas de la web. Es un servidor que gasta bastante energía, unos 100W en reposo (que casi siempre está en reposo), y hay muchas horas del día que no se usa.

Mi solución es apagar el servidor automáticamente por las noches. Apagarlo es sencillo, solo hay que llamar a /sbin/halt en el cron, pero el tema es encenderlo. Muchas BIOS soportar el encendido a una hora determinada, pero este server no, asi que no me queda otra que recurrir al Wake On LAN.

Todo lo que voy a explicar es debian. Si usas ubuntu o redhat… pues mejor cámbiate a debian :)

La idea es que enviando un paquete mágico (sí, se llama así), pues el ordenador se enciende solito. Para ello, la tarjeta de red tiene que esperar activamente a recibir ese paquete con su MAC, y ya le dice a la BIOS que encienda (con lo cual, si tienes un portatil, te puede consumir batería).

Lo primero es ver si tienes activada en la BIOS esa opción. Cada BIOS es distinta, pero suele estar en la parte de gestión de energía. Con esto, el ordenador responde a la petición de la tarjeta de red de encender.

Bien, después de tener lista la BIOS, tenemos que decirle a la tarjeta que responda a los paquetes mágicos. Para ello usaremos el comando ethtool, que nos permite cambiar cosas de la tarjeta de red.

sudo apt-get install ethtool

sudo /sbin/ethtool eth0

la linea que nos interesa es :

Supports Wake-on: g

puede tener mas cosas, pero al menos tiene que tener una g

Tendremos que decirle a la tarjeta que escuche por el paquete, para ello escribiremos:

sudo /sbin/ethtool -s eth0 wol g

y si ejecutamos ethtool de nuevo, comprobamos el estado de la tarjeta:

Wake-on: g

Muy bien! anotaremos la MAC de nuestra tarjeta de red :

ip link ls dev eth0

y nos fijamos en

link/ether xx:xx:xx:xx:xx:xx

Vale, ahora podemos apagar el ordenador (sudo /sbin/halt)

Para encender el ordenador, yo tengo un mini PC que hace de router, firewall, proxy, etc, y será el encargado de arrancar mi servidor con un script, /usr/local/bin/wol. Quizás si tenéis un raspberry pi, podríais usarlo también para encender los ordenadores (auque tendría que testearlo para asegurarme).

#!/bin/bash

OSIRIS_ETH0=00:25:64:3b:71:20

/usr/sbin/etherwake ${OSIRIS_ETH0}

bueno, tras un chmod +x /usr/local/bin/wol, ejecutamos el script, y comprobamos que efectivamente, nuestra máquina arranca. Bien!!

Desafortunadamente, el wake on lan hay que activarlo cada reboot :/ lo mejor es configurarlo en el fichero /etc/network/interfaces

iface eth0 inet static
   address 192.168.1.15
   broadcast 192.168.1.255
   netmask 255.255.255.0
   gateway 192.168.1.5
   post-up /sbin/ethtool -s eth0 wol g
   post-down /sbin/ethtool -s eth0 wol g

Para apagar el ordenador por la noche, configuramos el cron:

# m h dom mon dow user command
17 * * * * root cd / && run-parts --report /etc/cron.hourly
25 2 * * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.daily )
47 2 * * 7 root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.weekly )
52 2 1 * * root test -x /usr/sbin/anacron || ( cd / && run-parts --report /etc/cron.monthly )
#
30 3 * * * root /sbin/halt

Como veis, he cambiado también las horas del resto de cron, si no, nunca se van a ejecutar. Por si acaso, hay que recargar el cron (/etc/init.d/cron reload)

En la máquina que va a despertar al servidor:

30 8 * * * root /usr/local/bin/wol

Y listo, con esto tenemos ya un ahorro de unas 5 horas al día.

Para que os hagáis una idea, mis servidores usan 4.2kW al día, de los cuales el 60% del gasto es de este ordenador. Reducimos un 20% las horas que están encendidas, asi que tendremos 3.69kW:

4.2kW dia * 2 meses * 0.13 € kW más 21% IVA = 39.63 € cada factura

3.69kW * w meses * 0.13 € kW más 21 % IVA = 34.82 € cada factura.

Asi que al año nos ahorramos, 28.86 €, sólo por ejecutar este script.

Proyecto SROLL

Andaba yo pensando en hacer unos tests con motores, cosas de pulsos, etc, cuando se me ocurrió este proyecto.

Me hace falta algo que genere una secuencia de pulsos, PWM, que sea controlable, algo así como el 555, pero quizás con una pantallita, y una ruedecita para que sea práctico. También es necesario que sea transportable, que se pueda llevar por el taller, que sea portable, etc. Desde luego, que sea baratillo. que no se salga de madre de coste…

Así que se me ocurrió montar una especie de plataforma de desarrollo, basada en un atmega, y que funcione a pilas. La idea es que el avr lea de un encoder (ruedecita) valores, y los envíe a unos pines donde puedes conectar cosas. Algo muy sencillo: giras la ruedecita, y eso envía valores a los pines. Luego las placas de expansión ya harán el resto.

Para que sea sencillo, y además ampliable, se me ha ocurrido enviar valores PWM, valores por i2c, por SPI, e incluso decir cuando se pulsa un botón, cuando estamos en el mínimo/máximo, etc. y una entrada para que la placa de expasión nos dispare un evento (como que está lista, o algo asi)

Para controlar todo el proceso, he buscado una pantalla que se programa por UART. Sale un pelín cara, pero me deja muchos pines libres (y ademas, tiene varios colores de LEDs, que pueden servir de indicador).

La energía se suministra a través de un par de baterías normales de 1.5V, conectadas a un cebador que nos proporciona 5V. El circuito lo copié de un proyecto de adafruit, sencillo y sobre todo fácil de soldar.

En principio, todos los componentes se pueden soldar sin problemas (no he mirado la lista de todas las resistencias/condensadores, pero me imagino que no habrá problema)

Os dejo aquí el esquema : srollv1 . Yo creo que es sencillo, con una parte para la energía, que nos proporciona 5V de las pilas, la pantalla gráfica, el encoder (la ruedecita) que además sirve de pulsador, un conector ICSP para poder programar el avr, y 2 filas de conectores hembra para conectar luego las placas de expansión, y 2 pines para conectar un PWM de salida.

Es un esquema de 2 días, asi que seguramente sufrirá cambios, mejoras, y no está ni medio testeado.

Hay varias placas que quiero incluir. Una es un testeador de motores stepper. Meteré algo que traduzca el i2c a pulsos, y espacio para un driver pololu.

Otra cosa es un conversor digital a analógico, para poder ampliar tb a algo como un driver de LEDs, que varíe la intensidad, etc.

Lo que más me ha gustado es que es sencillo. Dada mi tendencia natural a complicarme la vida, es todo un logro :)

Hay varias piezas que salen aglo caras, como la pantalla (17€), pero no creo que bajo ningún concepto, sobrepase el presupuesto de 50€ de coste total.

Y lo mejor, el proyecto es open hardware :)

Manos a la obra con la PCB!!!

Este fin de semana, al fin, me he puesto manos a la obra, y me he puesto a probar todo lo que tenía preparado para revelar las PCBs en el taller.

El proceso, asi resumido, es:

1. Imprimir la máscara
2. Exponer luz ultravioleta sobre la placa fotosensible
3. Revelar la placa
4. Grabar el coble, donde no está protegido por la capa fotosensible

Qué circuito fabricar

Lo primero, es tener un circuito que vamos a fabricar. Como estos son los primeros circuitos que vamos a revelar, pensé que lo mejor es hacer un circuito de test, con todos los distintos tamaños, anchos de vía, circulitos, pads para los chips, etc. Y mirando en internet, encontré este circuito de test que me pareció genial. Como mi placa es de 100 mm x 160 mm , y quería hacer bastantes pruebas, pues lo ajusté un poco al ancho de 100 mm,  con este resultado.

enlace al PDF

En el fichero tenemos varios anches, vías que se cuelan entre pads, círculos, footprints estándards, etc. Lo de ponerle márcas de corte en las esquinas, me ha sido bastante útil luego, para centrar la máscara y la placa, cuando la vamos a exponer a la luz UV.

Imprimir la Máscara

La forma más común de imprimir la máscara, es usar hojas de película transparente. Yo he comprado un pack de 25 hojas A4 de la marca Avery, por unos 17 euros con gastos de envío y todo. El problema es que si lo imprimes con una impresora láser, el toner digamos que no es perfecto, y deja pequeños agujeritos en las zonas negras. La mejor opción es usar una impresora de tinta, pero ya quedan pocas.

Lo que se hace normalmente es imprimir dos veces la máscara, y solaparlas. Haciendo pruebas, me he dado cuenta que las máscaras me salía de peor calidad en la zona inferior de la hoja. Es algo que tampoco me gusta mucho, porque es posible que se muevan, o que queden mal.

Otra opción, que me gustó mucho, es usar papel cebolla. Con una hoja que tenía preparada, imprimí la máscara a ver qué tal quedaba.

Es importante que desactivemos el ahorro de tóner, para tener la máxima densidad de negro, y que la imagen salga lo más opaca posible. Os pongo las opciones que he usado en la canon ml 2160 (40 euros en amazon)

Esta es una foto comparando los 2 tipos de máscara. La imagen superior está impresa en la transparencia, y la inferior es papel cebolla. Se nota más en las líneas finas:

De todos modos, tras hacer este test, y volver a mirar en internet, lo que habría que hacer es imprimir la máscara en el folio normal, posteriormente aplicar aceite de girasol, y dejar secar. Voy a probarlo, a ver qué tal queda (la diferecia de precio es importante, y quizás quede mejor).

Otra opción es usar «ennegrecedor de tóner», que disuelve el polvillo, rellenando los poros. Pero no tengo, ni he encontrado a la venta.

Este es el resultado final. Están 2 máscaras una sobre otra, y fijadas con cinta adhesiva (yo usé la lupa para poder alinear todo de forma sencilla)

Exposición Luz Ultravioleta

Lo primero es cortar la PCB, cosa que no me resultó tan sencillo al principio, ya que pensaba que con unas pinzas sería chupado… pero no. Tuve que usar la rebarbadora para hacer los cortes.

Lo demás es bastante sencillo, si tenéis la insoladora lista. Simplemente ponemos la máscara entre dos cristales, lo fijamos con unos clips, que podéis comprar en una papelería, lo ponemos en la isoladora el tiempo necesario.

Es obio, pero es importante que el cristal esté limpio, que no dejemos suciedades entre la máscara y el cristal, huelas de dedos, etc. Y que la máscara esté bien pegada al cristal.

El vidrio que he usado, es verdoso si l miras por el canto, y eso parece indicar que filtra luz ultravioleta. Supongo que eso afecta al tiempo de exposición.

Asi que nada, ponemos en cristal, cerramos la tapa (esa luz es peligrosa  para la vista) y controlamos el tiempo con el móvil.

La primera vez lo tuve 160 secs, pero eso no fue suficiente. Las siguientes pruebas las puse 10 minutos, y mucho mejor.  No tengo ni idea de si sobre exponer puede ser malo. Entiendo que los bordes pueden perder máscara si lo tienes demasiado tiempo, y las vías muy muy finas (0.2/0.1 mm) pueden salir mal.

Revelar la placa

Aqui comienza la química. Para el revelado he usado simplemente sosa cáustica (se puede comprar en donde vendan productos de limpieza), con aprox 5 gramos por 0.5l de agua. Hay que remover bien para que la sosa se disuelva en el agua. Usad agua destilada, porque el agua del grifo tiene cal y cosas que se van a pegar a la placa, y la van a ensuciar. Yo lo que hago es guardarme el agua del deshumidificador… pero podéis comprarla en carrefour, en la sección de automóviles.

Cuidado con la sosa!!! Incluso en esta baja concentración, la sosa quema la piel y los ojos. Usad guantes, y no os toquéis los ojos mientras estais con estas cosas. Yo tengo siempre un ventilador de PC aspirando el aire…

Aqui lo del tiempo es importante. Si ponéis la placa poco tiempo, no saldrá la máscara, pero si lo ponéis demasiado, la sosa se comerá toda la máscara, y luego va a salir mal. Haciendo pruebas, en cuando veo que no sale más máscara disuelta, la retiro. Incluso podeis dejarla unos segundos, y luego ir aplicando con un pincel o un cepillo de dientes.

Leyendo por internet, he visto que los reveladores más «profesionales» no se «pasan», y puedes tenerlos más tiempo. Es algo que quiero mirar, porque en alguna prueba, creo que he revelado demasiado la márcara, y luego he perdido todo el cobre.

Para el revelado, he encontrado un par de tuppers en el carrefour por 1€, que son inertes a la química. La sosa, al contacto del agua, desprende calor, y en otras ocasiones, usar un recipiente cutre, pues me ha salido bastante mal.

Este es el resultado final. Como podéis ver, la sosa disuelve la máscara que ha sido expuesta a la luz UV. No os olvidéis de aclarar con agua, después de sacar la placa. No la sequéis porque se podría rayar.

Grabado (etching)

El siguiente paso es que la química se «coma» el cobre que está expuesto, y mantenga el cobre cubierto por la máscara, intacto.

Aqui hay varias soluciones. Yo he optado por mezclar ácido clorhídrico con agua oxigenada concentrada. El ácido clorhídrico se llama «salfumán» o agua fuerte (se vende en carrefour) y el água oxigenada concentrada de 110, la compré en una farmacia. El agua oxigenada quema. Me refiero a que quema mucho, ni se os ocurra tocarla. Usad guantes. La proporción es 50%/50%.

Esta mezcla es muy fuerte. Se come el cobre casi en segundos. Y suelta un gas supertóxico, que os puede dejar inconscientes. Yo lo que hice fue poner un super ventilador, y una máscara (en ferreterias, 10 por 2 euros o algo asi)

Tras varias pruebas, donde la mezcla se comía el cobre demasiado rápido (segundos), y las vías finas acababan desapareciendo antes de acabar, decidí mezclarlo con agua destilada. Todavía no he encontrado la proporcion adecuada, pero creo que es 1 medida ácido clorhídrico, 1 agua oxigenada concentrada, 4 de agua destilada. Con esto, la reacción es bastante más lenta y tranquila, y el resultado  final sale mucho mejor. No sé si afecta a la química, lo cierto es que sin agua, la mezcla se vuelve verde cuando se come el cobre, y con el agua, se vuelve azul. No sé si esto está bien o mal, pero a mi me parece que el resultado es mejor.

Hay que limpiar bien todo al terminar, y aclarar bien.

Resultado Final

Bueno, tras cortar los bordes con una guillotina, este es el resultado final. Todavía hay fallos, pero creo que el resultado es óptimo para hacer los circuitos que quiero montar aquí.

Hay cosas que quiero probar, como otra química, un revelador que no se «pase», una química más liguera para comer el cobre, probar a hacer los agujeros antes de revelar la placa, platear el cobre, aplicar una máscara de soldadura, probar con algún barniz, probar qué tal suelda todo, y sobre todo, montar mi primer circuito digital!!

Papel cebolla DIY

Sí sí, así como suena. Lo más avanzado en el proceso de fabricación de plácas electrónicas es el papel cebolla.

Para qué? Pues muy sencillo, para imprimir las máscaras de los prototipos con una impresora laser. Al parecer (nunca he impreso uno) si imprimes usando el típico plastico de presentaciones, pues resulta que el toner no acaba de imprimirse del todo (contando de que no imprimes con el modo ahorro de tinta), asi que, o bien imprimes 2 máscaras y las superpones, o bien usas algo para ennegrecer la impresión (he leido algo de algunas lacas, etc)

Pero leyendo por internet, veo que no es necesario usar papel transparente, sirve también papel cebolla, ya que deja pasar la luz ultravioleta. Y lo mejor, es que al parecer, puedes hacerte tú mismo el papel de cebolla.

El procedimiento es sencillo. Metes folios en aceite de girasol, y lo dejas secar 48 horas. Al parecer (es algo que os voy a confirmar más adelante) el aceite de girasol seca completamente, dejando el folio semitransparente.

Os pongo las fotos del proceso (100% galicia rural)

Como veis, la cosa pierde aceite… asi que usad unos cartones, o haced el proceso en una pileta o algo similar.

Isoladora terminada

Tras un par de semanas con trabajo, por fin pude ponerme de nuevo este fin de semana con la isoladora.

Tras poner a funcionar los tubos actínicos (como hablamos en los post anteriores), faltaba el tema de los soportes. Y por fin pude sacar un rato para imprimir las piezas necesarias. Las piezas están casi huecas, para que todo sea más ligero, pero con una parez gruesa de 3 mm (así es tambíen muy fácil luego atornillar el plástico)

Con cuatro piezas de plástico, ya tenemos el soporte, y todo lo necesario para montar nuestra isoladora.

El siguiente paso es conectar todas las partes y meterlas en una caja. Como me daba cosa estropear la caja, decidí usar un rectángulo de DM de base. El DM es lo que se usa, por ejemplo, en la parte de atrás de los cuadros enmarcados. Podéis comprarlo en cualquier tienda de enmarcación.

Os pongo unas fotos del montaje. El primer paso fue dibujar el circuito sobre el DM y colocar las piezas para que todo quedase más o menos recogido.

 

Las pruebas las realizo con el tubo de luz negra, que no sirven. De hecho, una vez me equivoqué, y reventé un tubo de esos, asi que si montáis vosotros la isoladora, cuidado con los tubos!

Y aquí está el resultado!!! isoladora montada (sin la tapa). Lo siguiente es comenzar con las pruebas, con el revelador, etc… a ver cómo sale.

 

 

Cambio a los fluorescentes actínicos

He dedicado estos días a informarme sobre la lámpara de rayos UV, leer foros, comentar ideas con otra gente, etc.

Un compañero, me recomendó no usar LEDs, y la verdad que los argumentos me parecieron interesantes. El problema principal es que con los LEDs, es complicado que salgan todos de la misma intensidad, y que la placa no quede expuesta de forma uniforme. No creo que tampoco sea un gran problema, pero es cierto que eso puede ocurrir.

Así que decidí tirar por los tubos fluorescentes.

Para conectarlos, es necesaria una «reactancia», y un «cebador». La reactancia sirve para 2 tubos, y el cebador, hace falta 1 por cada tubo. Son bastante comunes, y se venden en cualquier tienda de lámparas e iluminación. También venden los casquillos sueltos, que es lo que permite conectar los componentes sin tener que hacer chapucillas de cables.

Os pongo aqui el esquema usando avanzadas técnicas de CAD

El tema del tubo me pareció mas complicado. Yo simplemente busqué «fluorescente luz ultravioleta» y encontré varios por ebay. Busqué unos pequeños, que entrasen en la caja de albariño.

Si buscas luz ultravioleta, te salen tubos de luz negra. Yo compré los primeros que encontré, al mejor precio, pero como siempre, fue justo comprar los tubos, y decirme en un foro que esos no valian.

Bien.

Llamé a la tienda, y ellos me dijeron que sí que valen, que son los que ellos usan.  Ahora lo pongo en duda, pero bueno, tampoco fue mucha inversión (13 euros en total)

Al parecer, no tienes que usar luces ultravioleta, lo que necesitas son «luces actínicas», que es la luz que más se parece al sol. La luz negra parece ultravioleta, pero va en otra longitud de onda, y no sirve (o tarda mucho tiempo). Si no tienes luces actínicas, sirven los fluorescentes blancos normales.

Afortunadamente, cuando fui a comprar los casquillos, en la tienda también tenían los tubos actínicos, y el chico ya sabía «isolar» (revelar las placas PCBs) y me dió los tubos perfectos para revelarlo (por desgracia no tiene ningún código de referencia). Salen a unos 5 € cada uno. Cebadores, 2 reactancias casquillos y 3 tubos, 39 €. Como nota, la reactancia hay que comprarla de la medida correcta. Menos no enciende, más quemas el tubo.

Bien, hoy he montado un tubo de prueba. Como la luz negra no vale, he decidido probar primero con ese tubo, por si revienta algo, no fastidiar los tubos buenos.

Os pongo las fotos con las 2 luces, para que veais la diferencia.

Luz «negra», la que se usa en las discotecas y para los billetes falsos (esta NO VALE)

Luz «actínica». Es malo mirar esa luz directamente.

Lámpara de Revelado UV

Hacía tiempo que tenía en la cabeza la idea de hacer mis propias placas. Hacerlas en China es la mejor opción, pero tiene un problema: tarda muchísimo. Si quieres hacer test, pruebas, algo rápido… pues la verdad que no es muy práctico.

El principal reto es poder soldar chips con patillas pequeñas. Algo como un arduino leonardo, etc. Muchos componentes que suelo mirar, tienen ese tipo de empaquetados. Con una placa de fábrica y el soldador de aire caliente, no suele haber problema. Pero con algo casero… a ver, me da miedo.

El sistema que voy a utilizar es el de aplicar luz ultravioleta sobre la placa, pero con el circuito impreso haciendo de máscara. Usándo la química, quitaremos el cobre en las zonas expuestas la luz UV. Esto nos permite transferir el circuito con gran definicion a la placa.

Así que lo primero que necesito es una lámpara UV. Las venden por 150 euros, pero yo creo que se puede hacer por menos. Rebuscando, encontré por casa una caja de alvariño (tope casero), que creo que me va a servir a la perfección.

Mi idea es, con un poco de maña, transformar eso en esto:

 

La base son unos 150 LEDs de 5mm, soldados a una placa de baquelita. Una fuente de alimentación de 12V 4A que tengo por aquí, y unas piezas impresas con la impresora 3D.

Esta será la primera versión, totalmente manual: enchufas la fuente y se enciende.

La parte teórica. Pues los LEDs consumen unos 20mA. Tienen una caida de voltaje de 3,2 – 3,8V, y un ángulo de brillo de 20º.

Si los LEDs están separados por 4 agujeritos, y los agujeritos est’an separados por 2.54 mm. Pues esto nos sale que por trigonometría, los 20º de los LEDs se encuentran a 36mm. El cristal está a 50mm de los LEDS, suficiente para que la luz sea uniforme, y que no perdamos mucha energía.

Los LEDs necesitan una resistencia (soportan como máximo 40mA).

Asi, la resistencia debería de ser, por la ley de ohm,  R=V/I. El voltaje es de 12V – 3.2V que mínimo se come el LED = 8.8V. Dividido por 0.002A que consume, nos dá R=440Ohm.

Si en vez de 1 resistencia por LED, ponemos 1 resistencia por cada 3 LEDS, tenemos:

R=(12V – 3*3.2V)/ 0.02 A = 120 Ohm.

Asi que meteremos 50 resistencias de 120 Ohm, 150 LEDs, y un conector para atornillar el cable de alimentación. El consumo esperado es de 150*20mA = 3A  (que a 12V eso es 36Watios de potencia). Necesitamos unos conectores algo buenos, que soporten unos 5A más o menos. Hay que repartir bien las conexiones, para que la corriente no pase toda por el mismo punto, asi que dividiré la baquelita en varias secciones (espero que eso no afecte al brillo, es importante que sea uniforme)

Bueno, ahora a pedir todo y esperar.

 

Empezando un nuevo blog

Llevo desde agosto intentando encauzar todos los proyectos que ahora mismo tengo en la cabeza, que no son pocos… El cacao es importante. Tengo cosas de electrónica, de comercio electrónico, ERP, Impresión 3D. un cristo de cuidado.

Una de las cosas importantes en esta «nueva etapa» que comencé desde el verano es volver a ser activo en internet. Mi primera prueba fue montar un blog para hablar de una placa ARM. La idea fue montar un blog e ir contando lo que se iba haciendo (http://sunxiboards.wordpress.com). La cosa ha funcionado muy bien, y la experiencia es positiva. Ahora voy a comenzar otra etapa, que va a ser una aventura en castellano, para dar visibilidad a los proyectos que estoy realizando ahora mismo, y creo que muy interesantes (Así a bote pronto) :

• Montar una Prusa i3.
• Revelar mis propias placas PCB.
• Diseñar y fabricar una fuente de alimentación de laboratorio «low cost» programable.
• Diseñar la nueva versión de la placa SBOT para controlar la impresora 3D.
• Un teclado mecánico.
• Un variador para motores de quadcópteros.
• Diseñar y fabricar un switch ethernet con soporte VLAN.
• Diseñar y fabricar un router linux ARM.
• La nueva versión de printallthethings (la web donde vendo material de impresora 3d)
• Montar una nueva mesa para la máquina CNC.
• Reorganizar la red de la empresa, que está patas arriba.
• Montar una aplicación web para controlar los presupuestos de la empresa.

Os parece poco? XD Lo cierto es que estoy abrumado. Pero aquí está todo, en la lista de cosas que voy a ir trabajando, de lo que iré publicando, y si hay suerte, en lo que podréis ayudarme :)