miércoles, 28 de septiembre de 2011

COMO HACER UN DESOLDADOR CASERO CON UN COMPRESOR DE AIRE BARATO

Para repasar: Compresor de pistón.

 
Esta vez se trata de ahorrarse algo de dinero. Si no puedes permitirte el lujo de comprarte un buen desoldador, como era mi caso hace unos años, aquí te propongo un apaño mucho más útil que las bombas de succión o las peras de goma.y casi tan eficaz como uno profesional. Sólo le faltaría la regulación de temperatura.

 La idea surgió al encontrar, tiradísimo de precio en un supermercado, uno de esos compresores para inflar una colchoneta que se enchufan al mechero del coche.

 Y la idea es sencilla. Un compresor para inflar suelta el aire por un extremo pero necesita "absorberlo" por otro. Si  encontramos el orificio por donde entra el aire, tendremos el punto por el que "chupar" el estaño. Únicamente tendremos que unirlo a una punta desoldadora y añadir algún tipo de filtros para que el estaño no llegue al compresor.


Este compresor es de pistón. Funciona de forma similar al émbolo de una jeringuilla. Cuando tiramos absorbe el aire, y cuando empujamos lo hecha. Si tenemos un par de orificios y cada uno de ellos dispone de una válvula que tapone el aire en sentidos inversos tendremos un orificio por el que entra el aire y otro por el que sale. Algún mecanismo (como un motor eléctrico en nuestro caso) moverá el émbolo (en nuestro compresor un cigüeñal, biela y cilindro similar al motor de un coche).


  

En mi caso destripo un poco el compresor para buscar los orificios de entrada A y salida B del aire.


Por el orificio A entra el aire. Por el tubo B sale el aire hacia la goma de salida. Ahora el trabajo consiste en poner una goma al orificio A por la que "chupar" el aire.


 Se puede observar el cilindro desmontado. Se observa el pistón que actúa dentro del cilindro. Las válvulas de entrada y salida del aire son unas gomitas colocadas en dos orificios en la tapa del cilindro.


 La gomita A está por dentro del cilindro sujeta con una chapita. Baja cuando entra el aire. La gomita B está por fuera del cilindro. Sube cuando sale el aire.




El primer problema me lo encontré con el poco espacio para colocar una goma sobre el orificio de entrada de aire (A). Se trata de un agujero demasiado pequeño. Mi opción fue la aguja de una jeringilla para pinchar caballos. La parte metálica la corté. Se trata de que introduzca por el orificio pero no obstruya el "sube y baja" de la válvula de admisión.

Pegué con pegamento rápido. La cánula de plástico que uniría la aguja a la jeringuilla, que se observa bien en la foto, me servirá para sujetar un tubo algo más grueso con silicona, al que unir la goma de entrada de aire.



Ya tengo el compresor adaptado para conectar la "absorción" de aire. Usaré un tubo de latón de 4mm de diámetro para las uniones que conseguí en una ferretería. Gomas. La azul me la regalaron en una tienda de repuestos de coches. Buscaba algo resistente que aguantase algo de calor. La transparente se usa en los presostatos de las lavadoras. A mi desoldador de pera le saco la pera de goma.

Se trata ahora de unir la punta desoldadora con la entrada de aire del compresor. Pero aquí tenemos otro problema. El estaño que absorbamos no puede llegar a las válvulas del compresor porque las estropearía. Es necesario hacer unos filtros.


Lo he solucionado con las cajitas de unos carretes de fotografía, al que he hecho dos orificios en los extremos y he introducido unas conexiones de tubo flexible pegado con silicona. El filtro que habrá que cambiar cada cierto tiempo será con un trozo de esponja. He puesto dos filtros. Uno cerca de la punta desoldadora y otro cerca del compresor (el que tengo transparente para poder ver si se acumula el peligroso estaño).

Aquí se puede ver la parte mecánica. Ahora solo nos queda poner una fuente de alimentación y pulsador a modo de interruptor para accionar el compresor. Me he encontrado con que el consumo de corriente es demasiado alto para mi fuente de alimentación de laboratorio (un poco más de 3 A) así que he montado todo con un transformador más puente rectificador que tenía de desguace tirado por el desván. Ya ves que el filtraje y la calidad de la tensión no es importante, siempre que sean los 12v en continua, que muestra en las características el compresor que originalmente era para el mechero de un coche. Que el filtrado y estabilizado de la tensión sea deficiente no tiene importancia.



El esquema eléctrico, creo que no tiene complicación. Un pulsador dispuesto en el mango del desoldador dará paso a la corriente hacia el compresor. OBSERVA QUE TRABAJAMOS SÓLO CON 12 V EN CONTINUA, COMO LA BATERÍA DE UN COCHE. NO SE TE OCURRA PONER UN PULSADOR CON MÁS TENSIÓN (220V O 115V) EN LA PUNTA DEL DEDO.


El resultado es el esperado. El compresor "anda" un poco por la mesa y es algo ruidoso, pero cumple su función perfectamente. Está claro que aquí propongo chapuzas. El sujetar todo un poco mejor y hacerlo más bonito está en tus manos, pero la operatividad es buena.
Os dejo una prueba en video.  (Este enlace es al primer sitio en donde he colgado el video: TuTV. Por publicidad excesiba, continuos fallos, e inoperabilidad, en el cuadro de video que sigue he optado por youtube a fecha Sept2016. Conservo, de alguna manera, los dos enlaces, para aumentar las posibilidades de visionado)





Como siempre espero que esto le pueda servir a alguien y acepto comentarios... Un saludo.


viernes, 24 de junio de 2011

Como hacer funcionar un display spi VFD (Vacuum Fluorescent Display) Pinguino (o arduino)+16LF01UA3






PARA REPASAR: Datasheet del display 16LF01UA3 (lo he consiguido en pdf buscando en la web por "16lf01ua3 untitle"); Pinguino Pic (lo mismo que arduino pero con microcontrolador de Microchip del que he comentado en una entrada anterior, software libre y hardware libre fácil de construir, que puedes ver si buscas en la web "pinguino pic hackinglab", fíjate expecialmente en el tutorial; conocimientos básicos de programación en C, tener un Manual de progamción Arduino que puedes también descargar en pdf desde la red para conocer que ordenes de c se pueden usar con arduino.



Esta vez se trata de hacer funcionar un display alfanumerico VFD (Display Fluorescente de Vacio). He conseguido alguno de despieces, y he encontrado documentación de éste en internet (16LF01UA3). Mi idea original es tratar de imitar un luminoso publicitario que pase continuamente un mensaje de derecha a izquierda.
Con una ojeada a la hoja de características del display Samsumg 16LF01UA3 nos hacemos con los pines y una idea de su funcionamiento.

Pin1 y pin2: Vcc(+5v).
Pin3,4,5,6,7: No conectados. El 3 falta como "llave" que impida conectar al revés.
Pin8: SCLK Activa por flanco de bajada el bit que señale DATA.
Pin9: DATA El bit (0 ó 1) se va añadiendo a un registro cada vez que SCLK baja de 1 a 0 hasta que forma un byte (8 bits) como código de control del display.
Pin10: /RST A nivel bajo activa el reset de todo el display.
Pin11 y pin12: GND


Así que tendremos que alimentar con 5 voltios al display (pines1-2, 11-12), y el "Pinguino" (placa similar a Arduino) que usaremos para manejar los tres pines: SCLK, DATA, y RESET.

Monto todo sobre una protoboard. En la programación del Pinguino "definiremos" como salidas: la 7 para el SCLK, la 6 para el RESET, y la 5 para el DATA.





Como mi experiencia con el pinguino es mínima, y aquí se trata de aprender, no me preocuparé de librerias previas, ni aprovecharé lo que hayan hecho otros. Programaremos "como los hombres", a pelo, usando las ordenes más elementales y genéricas para ir montando nuestras funciones... Creo que he descrito ampliamente con notas en el código pero aclararé como he ido planteando el asunto.
El display se maneja, basicamente, "emitiendo" secuencias de bits, que en grupos de 8 forman "palabras" que el display va entendiendo de determinada manera. Los códigos vienen en la hoja de características del display. El display alamacenará un bit cuando la señal SCLK pase de nivel alto (5v) a bajo (0v) y ese bit será el que en ese momento tenga el pin DATA. La señal /RESET deberá permanecer a nivel alto. A nivel bajo reseteará todo y tendremos que volver a empezar.
Lo primero ha sido la funcion sclkfall() que hace que la señal de SCLK pase a nivel bajo y por tanto el display "acepte" lo que hay en DATA. Y luego, usando ésta defino l() para meter un uno (5v), y o() para "meter" un cero (0v). OJO: l() parece un uno pero es una "L"minúscula, y o() parece un cero pero es una "O"minúscula. Uso el parecido porque no puedo hacer una función que empiece por un número y de esta forma , a posteriori es muy cómodo, porque es fácil ver el byte que queiro enviar en cada momento. Luego todo es enviar bytes. ¿Cúal?, se sabe mirando la hoja de características, aunque voy explicando en el código.


// Probando display vfd 16LF01UA3

// Usaremos un pinguino con pic18f2550
// Anadir la linea siguiente si es con pic18f4550
// #define PIC18F4550


#define SCLK 7 //manejaremos SCLK por pin7
#define RST 6 // /RST por pin6
#define DATA 5 // DATA por pin5

int colocarPuntero(int En);//Prototipado porque pasa valor
////////////////////////////////////////////////////////////
// TEXTO PARA EL DISPLAY en modo scroll AQUI
char Mensaje[100]="Jueves, 16 de junio ";// 3" "al final
int posicionUltLetra=22;
// TAMAÑO ARRAY Mensaje[x] DEBE SER MAYOR QUE EL NUMERO DE CARACTERES
// posicionUltLetra INDICARA EL NUMERO DE CARACTERES.
////////////////////////////////////////////////////////////
int scroll=1;// 1=>Desplazamiento continuo del texto izq-der
// 0=>No se controla el desplazamiento.
// 2=>Prueba (poniendo codigo en su sitio) cosas nuevas
////////////////////////////////////////////////////////////

char digDisplay[17]=" ";// 17 espacios
//Representa los caracteres en cada
// posicion del display, usaremos [1...16]
// uno por cada digito. El [0] no lo usamos
int posicionMensaje,i;
//No.1er.caracter escribir en display
// i contador que no puedo definir en loop()


/////////////////////////////////////////////
void setup()
{
pinMode(SCLK,OUTPUT); //Todas seran salidas hacia
pinMode(RST,OUTPUT); //el display
pinMode(DATA,OUTPUT);

resetdisplay(); // La primera vez reseteamos display
numdigit(); // configuramos el numero de digitos
brillo(); // la intensidad de los digitos
BorrarDisplay(); // Borrar
posicionMensaje=0;//Por donde empezaremos a leer el Mensaje[]
}

void loop()
{

if(scroll==1)
{
// Guardamos en cada digDisplay[i] el caracter que le toca a ese digito
// Pretendemos que el texto corra de derecha a izquierda continuamente
for(i=1;i<16;i++)
{
digDisplay[i]=digDisplay[i+1];
//Cada digito corre de derecha a izquierda
}
digDisplay[16]=Mensaje[posicionMensaje];
//El ultimo digito de la derecha es el nuevo que leemos de Mensaje[]

if (posicionMensaje==posicionUltLetra)
// Si era el ultimo caracter hay que volver a leer por el principio
{
posicionMensaje=0;
}
else
// Si todavia no llegamos preparamos para leer el siguiente
{
posicionMensaje=posicionMensaje+1;
//La siguiente vez leeremos el caracter siguiente de Mensaje[]
}



// Representamos cada caracter en su digDisplay
for(i=1;i<17;i++)
{
colocarPuntero(i);
switch(digDisplay[i])
{
case '@':Arroba();break;
case 'A':case 'a':A();break;
case 'B':case 'b':B();break;
case 'C':case 'c':C();break;
case 'D':case 'd':D();break;
case 'E':case 'e':E();break;
case 'F':case 'f':F();break;
case 'G':case 'g':G();break;
case 'H':case 'h':H();break;
case 'I':case 'i':I();break;
case 'J':case 'j':J();break;
case 'K':case 'k':K();break;
case 'L':case 'l':L();break;
case 'M':case 'm':M();break;
case 'N':case 'n':N();break;
case 'O':case 'o':O();break;
case 'P':case 'p':P();break;
case 'Q':case 'q':Q();break;
case 'R':case 'r':R();break;
case 'S':case 's':S();break;
case 'T':case 't':T();break;
case 'U':case 'u':U();break;
case 'V':case 'v':V();break;
case 'W':case 'w':W();break;
case 'X':case 'x':X();break;
case 'Y':case 'y':Y();break;
case 'Z':case 'z':Z();break;
case '(':AbreParentesis();break;
case '\\':BarraIzqDer();break;
case '/':BarraDerIzq();break;
case ')':CierraParentesis();break;
case '_':GuionBajo();break;
case '\"':Comillas();break;
case '#':Almohadilla();break;
case '$':Dolar();break;
case '%':Porcentaje();break;
case '&':Andpersand();break;
case '\'':Apostrofe();break;
case '<':MenorQue();break;
case '>':MayorQue();break;
case '*':Asterisco();break;
case '+':Mas();break;
case ',':case ';':Espacio();PuntoyComa();break;// El ; y el .
case '.':Espacio();Punto();break;//se asocian al ultimo
case '0':Cero();break; //caracter. No hay coma pero queda
case '1':Uno();break; //parecido el punto y coma.
case '2':Dos();break;
case '3':Tres();break;
case '4':Cuatro();break;
case '5':Cinco();break;
case '6':Seis();break;
case '7':Siete();break;
case '8':Ocho();break;
case '9':Nueve();break;
case '?':Interrogacion();break;
case '=':Igual();break;
case ' ':Espacio();break;
default:Espacio();
}
}
delay(400); //Retraso para poder visualizar
BorrarDisplay();
}


if (scroll==0)
{
// Poniendo al principio la constante scroll a 0
// cada letra (llamada a su funcion) ira despues
// de la anterior y al acabar empezara linea nueva.
BorrarDisplay();
H();O();L();A();Espacio();
M();U();N();D();O();Punto();Espacio();
delay(1000);BorrarDisplay();
Q();U();E();Espacio();
T();A();L();Espacio();
E();S();T();A();M();O();S();Interrogacion();
delay(1500);
}
if (scroll==2)
{
// Poniendo la constante scroll a 2 aquí puedes
// hacer pruebas si arriesgar demasiado...
}
}//////////////////////////////////////////////////////////


// Funciones para controlar el display
// Ver datasheet 16lf01ua3.
void sclkfall() // SCLK activa por flanco
{ // de bajada lo que marque DATA
digitalWrite(SCLK,HIGH);
digitalWrite(SCLK,LOW); // y preparando la siguiente bajada
digitalWrite(SCLK,HIGH);// vuelve a quedar a nivel alto
}


void o() // La funcion o() ("o" minuscula) marca un 0
{
digitalWrite(DATA,LOW);
sclkfall();
}
void l() // La funcion l() ("L" minuscula) marca un 1
{
digitalWrite(DATA,HIGH);
sclkfall();
}



void resetdisplay() // resetea el display
{ // activando a nivel bajo RST mas
digitalWrite(RST,LOW); // de 1ms y volvieno a nivel alto
delay(2); // para funcionamiento normal
digitalWrite(RST,HIGH);
delay(2);
}


void numdigit() // Define cuantos digitos usaremos
{ // los 16 en este caso "11000000"
l();l();o();o();o();o();o();o();
}


void brillo() // Para configurar la intensidad del display
{ // Maxima 11111111
l();l();l();l();l();l();l();l();
}


int colocarPuntero(int En)// Elege el digito que se va a escribir
{
l();o();l();o();// Primer cuarteto ordena control de puntero 1010

switch(En) // Segundo cuarteto indica dígito. De izq. a der.
{ // El primero 1111 y siguientes 0000,0001,...1110
case 1:l();l();l();l();break;
case 2:o();o();o();o();break;
case 3:o();o();o();l();break;
case 4:o();o();l();o();break;
case 5:o();o();l();l();break;
case 6:o();l();o();o();break;
case 7:o();l();o();l();break;
case 8:o();l();l();o();break;
case 9:o();l();l();l();break;
case 10:l();o();o();o();break;
case 11:l();o();o();l();break;
case 12:l();o();l();o();break;
case 13:l();o();l();l();break;
case 14:l();l();o();o();break;
case 15:l();l();o();l();break;
case 16:l();l();l();o();break;
default:l();l();l();l();
}
return(0);
}


void BorrarDisplay() // Borra escribiendo 16 espacios
{
int c;
colocarPuntero(1);
for (c=1;c<17;c=c+1)
{
Espacio();
}
}

void Retraso()
{
delay(0); // Ajustar restraso para poder leer
}



////////// Definiciones de letras //////////////

void Arroba() // Codigo para escribir @ 00000000
{o();o();o();o();o();o();o();o();Retraso();}
void A() // Codigo para escribir A 00000001
{o();o();o();o();o();o();o();l();Retraso();}
void B() // Codigo para B 00000010
{o();o();o();o();o();o();l();o();Retraso();}
void C() // Codigo para C 00000011
{o();o();o();o();o();o();l();l();Retraso();}
void D() // Codigo para escribir D 00000100
{o();o();o();o();o();l();o();o();Retraso();}
void E() // Codigo para escribir E 00000101
{o();o();o();o();o();l();o();l();Retraso();}
void F() // Codigo para escribir F 00000110
{o();o();o();o();o();l();l();o();Retraso();}
void G() // Codigo para escribir G 00000111
{o();o();o();o();o();l();l();l();Retraso();}
void H() // Codigo para escribir H 00001000
{o();o();o();o();l();o();o();o();Retraso();}
void I() // Codigo para escribir I 00001001
{o();o();o();o();l();o();o();l();Retraso();}
void J() // Codigo para escribir J 00001010
{o();o();o();o();l();o();l();o();Retraso();}
void K() // Codigo para escribir K 00001011
{o();o();o();o();l();o();l();l();Retraso();}
void L() // Codigo para escribir L 00001100
{o();o();o();o();l();l();o();o();Retraso();}
void M() // Codigo para escribir M 00001101
{o();o();o();o();l();l();o();l();Retraso();}
void N() // Codigo para escribir N 00001110
{o();o();o();o();l();l();l();o();Retraso();}
void O() // Codigo para escribir O 00001111
{o();o();o();o();l();l();l();l();Retraso();}
void P() // Codigo para escribir P 00010000
{o();o();o();l();o();o();o();o();Retraso();}
void Q() // Codigo para escribir Q 00010001
{o();o();o();l();o();o();o();l();Retraso();}
void R() // Codigo para escribir R 00010010
{o();o();o();l();o();o();l();o();Retraso();}
void S() // Codigo para escribir S 00010011
{o();o();o();l();o();o();l();l();Retraso();}
void T() // Codigo para escribir T 00010100
{o();o();o();l();o();l();o();o();Retraso();}
void U() // Codigo para escribir U 00010101
{o();o();o();l();o();l();o();l();Retraso();}
void V() // Codigo para escribir V 00010110
{o();o();o();l();o();l();l();o();Retraso();}
void W() // Codigo para escribir W 00010111
{o();o();o();l();o();l();l();l();Retraso();}
void X() // Codigo para escribir X 00011000
{o();o();o();l();l();o();o();o();Retraso();}
void Y() // Codigo para escribir Y 00011001
{o();o();o();l();l();o();o();l();Retraso();}
void Z() // Codigo para escribir Z 00011010
{o();o();o();l();l();o();l();o();Retraso();}
void AbreParentesis() // Codigo para escribir ( 00011011
{o();o();o();l();l();o();l();l();Retraso();}
void BarraIzqDer() // Codigo para escribir \ 00011100
{o();o();o();l();l();l();o();o();Retraso();}
void BarraDerIzq() // Codigo para escribir / 00101111
{o();o();l();o();l();l();l();l();Retraso();}
void CierraParentesis() // Codigo para escribir ) 00011101
{o();o();o();l();l();l();o();l();Retraso();}
void GuionBajo() // Codigo para escribir _ 00011111
{o();o();o();l();l();l();l();l();Retraso();}
void Comillas() // Codigo para escribir " 00100010
{o();o();l();o();o();o();l();o();Retraso();}
void Almohadilla() // Codigo para escribir # 00100011
{o();o();l();o();o();o();l();l();Retraso();}
void Dolar() // Codigo para escirbir $ 00100100
{o();o();l();o();o();l();o();o();Retraso();}
void Porcentaje() // Codigo para escribir % 00100101
{o();o();l();o();o();l();o();l();Retraso();}
void Andpersand() // Codigo para escribir & 00100110
{o();o();l();o();o();l();l();o();Retraso();}
void Apostrofe() // Codigo para escribir ' 00100111
{o();o();l();o();o();l();l();l();Retraso();}
void MenorQue() // Codigo para escribir < 00101000
{o();o();l();o();l();o();o();o();Retraso();}
void MayorQue() // Codigo para escribir > 00101001
{o();o();l();o();l();o();o();l();Retraso();}
void Asterisco() // Codigo para escribir * 00101010
{o();o();l();o();l();o();l();o();Retraso();}
void Mas() // Codigo para escribir + 00101011
{o();o();l();o();l();o();l();l();Retraso();}
void PuntoyComa() // Codigo para escribir ; 00101100
{o();o();l();o();l();l();o();o();Retraso();}
void Menos() // Codigo para escribir - 00101101
{o();o();l();o();l();l();o();l();Retraso();}
void Punto() // Codigo para escribir . 00101110
{o();o();l();o();l();l();l();o();Retraso();}
void Cero() // Codigo para escribir 0 00110000
{o();o();l();l();o();o();o();o();Retraso();}
void Uno() // Codigo para escribir 1 00110001
{o();o();l();l();o();o();o();l();Retraso();}
void Dos() // Codigo para escribir 2 00110010
{o();o();l();l();o();o();l();o();Retraso();}
void Tres() // Codigo para escribir 3 00110011
{o();o();l();l();o();o();l();l();Retraso();}
void Cuatro() // Codigo para escribir 4 00110100
{o();o();l();l();o();l();o();o();Retraso();}
void Cinco() // Codigo para escribir 5 00110101
{o();o();l();l();o();l();o();l();Retraso();}
void Seis() // Codigo para escribir 6 00110110
{o();o();l();l();o();l();l();o();Retraso();}
void Siete() // Codigo para escribir 7 00110111
{o();o();l();l();o();l();l();l();Retraso();}
void Ocho() // Codigo para escribir 8 00111000
{o();o();l();l();l();o();o();o();Retraso();}
void Nueve() // Codigo para escribir 9 00111001
{o();o();l();l();l();o();o();l();Retraso();}
void Interrogacion() // Codigo para escribir ? 00111111
{o();o();l();l();l();l();l();l();Retraso();}
void Igual() // Codigo para escribir = 00111101
{o();o();l();l();l();l();o();l();Retraso();}
void Espacio() // Codigo para el espacio 00100000
{o();o();l();o();o();o();o();o();}

/////////////////////////////////////Sancos 16-6-2011
////////////////////////////////////

El código sale aquí un poco enmarañado porque si copio y pego pierdo los tabulados. Pero para seguir un poco las explicaciones sirve.
Si quieres acceder al "archivo.pde" que puede leer directamente el IDE del pinguino, puedes descargarlo desde aquí.
Actualmente yo estoy usando la versión "Pinguino beta 9.04" y es con la que he probado todo esto.
También me ha parecido útil el que puedas descargar el programa como "documento.doc" para que sea más legible con colores y sangrados. Pero recuerda que esto no correrá en el editor del Pinguino. Tendrías que pasarlo escribiendo a pelo.

También añado aquí (a Diciembre del 2014) si quieres descargar una versión revisada para arduino ("archivo.ino"). Probado con arduino uno y el ide 1.0.4 a raiz de un comentario anónimo del  6 de diciembre de 2014 (léelo para observaciones) advirtiendo de que el código para pinguino no compilaba en arduino.

Al final he usado un if para, según el valor de la constante scroll, escoger un código que hace pasar de derecha a izquierda lo que pongamos en Mensaje[x] (video que pone una fecha); o no controlar la posición de cada letra y que sea el display el que automaticamente ponga una tras otra (video "Hola mundo, como estamos?"); o en una tercera opción, podemos hacer pruebas sin estropear lo que sabemos que funciona. En esta última parte no he puesto código.

Supongo que se entiende facilmente que las funciones l(), y o() envían, respectivamente, un 1 y un 0 al display.

Para cada letra se llama a su función correspondiente. Esta envía ceros y unos con el código correcto, según la hoja de características. Observa que el código que corresponde a escribir una letra tiene como bit más significativos (los primeros que se emiten) dos ceros, y los seis restantes indican la letra. Los que no empiecen por dos ceros son códigos de control: el brillo (yo sólo uso el maximo- brillo() -),número de dígitos (yo uso los 16- numdigit() -),la posición del siguiente caracter (aquí la función no es tan simple porque para conseguir que parezca que se desplacen tengo que posicionar cada letra- colocarPuntero() -y uso todos los códigos).
Algunas funciones especiales son: resetdisplay() en la que activo la linea de reset, o BorrarDisplay() que escribe 16 espacios. La función retraso() ,que aquí parecerá inútil, permite hacer pruebas con diferentes velocidades. Si escribes todo sin perder tiempo no verás nada.

Si al principio del código pones scroll=0 el asunto solo se tratará de ir "llamando a letras" estas irán apareciendo en la posición 1, luego 2, luego 3,...luego 16, luego 1, luego 2... Esto lo hace automaticamente el display 16LF01UA3. Al poner una letra suma la siguiente posición un paso, excepto para la coma y el punto.

Si el scroll=1, se complica un poco la cosa. Porque intento que el texto (el que quieras poner en Mensaje[x]) se desplace continuamente como en un luminoso publicitario. Mensaje[x] es un array. Necesitas que el texto quepa dentro, así que x debe de ser al menos el número de caracteres que quieras representar. El primer carácter será Mensaje[0] y el último Mensaje[x-1]. Observese que Mensaje[x] debería ser un carácter especial que marque el final de la cadena. He tenido problemas con esto. Así que en vez de "calcular" el final de la cadena, he optado por utilizar una constante posicionUltLetra que me marca cual es la última letra.
Luego el truco será en usar la cadena puente digDisplay[17] que se corresponderá a cada caracter real del display (1...16). Será 17, porque la posición 0 y 17 no se usan. Al principio esta cadena tiene espacios. Luego iremos pasando cada letra un puesto a la izquierda. ¿Y que pasa con la última? Pues que será la nueva, que vamos controlando con posicionMensaje teniendo en cuenta que después del final, vendrá el principio.
Una vez que tenemos la cadena digDisplay[17] llena de forma apropiada, escribimos cada elemento en su posición, llamando a las función más apropiada.
Y repetimos...



Espero no haberme liado mucho.
Me gustaría que hicieseis comentarios, aunque no sean demasiado buenos. Si son constructivos prenderé más. Y también me gustaría saber si alguien lo lee...


Bueno os dejo los videos.

Con desplazamiento, tipo luminoso publicitario:

Videos tu.tv

Y sin desplacamiento:

Videos tu.tv

POR FAVOR, valoraría comentarios... y siento la posible publicidad en mis enlaces pero es lo que tienen los alojamientos gratuitos...
Saludos.

domingo, 22 de mayo de 2011

Mi propia insoladora casera

Para repasar: cómo montar un fluorescente.
Aquí os dejo unas fotos de mi insoladora para hacer placas de circuito impreso. Había pensado en comprarla. Pero me encontré con que, o eran muy sencillas y no permitian hacer circuitos de doble cara, o las buenas me parecían demasiado caras. Así que me monté este armatoste en una caja de botellas de vino. Ha salido un poco pesada pero muy práctica.
El montaje tiene sus años, así que no hay fotos de como la he ido haciendo. Pero creo que la idea se percibe perfectamente. Y os dejo una foto con el esquema que he hecho para aclararme con el cableado. Basicamente se trata de una ristra de fluorescentes de 6w, de luz ultravioleta, en paralelo. He puesto el cableado por fuera para aprobechar el espacio interior. Y luego le he incorporado un temporizador mecánico que he sacado del despiece de un horno. Un interruptor permite que solo alumbren las lámparas superiores o ambas, superiores e inferiores. Dos cristales permiten colocar la placa y el fotolito.

Para un caso práctico de su uso, haciendo una placa de circuito impreso, hecha un vistazo aquí.








miércoles, 16 de marzo de 2011

Ordenar el taller de electronica

Aquí estoy de nuevo. Creo que he tenido una buena idea para organizar los repuestos de despieces de mi taller electrónico. Os pongo unas fotos que necesitan poca aclaración.
Para los integrados grandes he usado cajas de cintas de video que iba a tirar y les he pegado la típica plancha de corcho blanco que ya usaba para tener pinchados mis componentes. Ahora los tengo organizados por tipo de dispositivo, memorias eprom, microcontroladores, rams,... La única nota para tener en cuenta: El corcho hay que pegarlo con cola de carpinteria que no tenga disolventes. Si no se "derrite" el corcho. Yo he usado unos botecitos amarillos "Cola blanca Cyes".
Esto no es demasiado imaginativo porque deriva de pinchar los integrados en corchos...

Lo que sí que me parece más novedoso es la siguiente idea: cajas de cd.
Tienen que ser de las clásicas, nada de extrafinas. Les saco las cartulinas de las caratulas, corto el plastico interior que sorporta el cd y dejo solo el canto para hacer de visagra y sujetar un pequeño papel a modo de lomo en donde apuntar las referencias. Así, basicamente, tenemos la caja del cd vacía y transparente. Dentro queda el hueco justo para un integrado típico DIP. El unico problema es que resbala por el "cristal". La solución una esponjita. Yo he resuelto perfectamente con recortes del aislante que se pone debajo de los suelos de tarima flotante. Es barato comprandolo por metro y no un rollo enterro en una gran superficie...



La sorpresa surge cuando veo que los integrados tipo SMD encajan bastante bien y no escurren, o incluso puedes pinchar las patillas estirando un poco la esponjilla.
Más dificil son los condensadores y resitencias smd que no tienen patas. Lo he resuelto con cinta de pegar de doble cara. Veremos cuando las despegue despues de años... Pero como la caja es transparente no hay que tocarlos los integrados que se estan quietecitos...
La verdad es que sin gastar demasiado dinero me gusta como todo está organizado.


martes, 18 de enero de 2011

ADAPTADOR 220AC A 6DC PARA APARATOS A PILAS

Para repasar: transformadores, rectificador de media onda, filtro por condensador, regulador de tension.


Aquí está mi siguente chapucilla...
El problema es el siguiente. Tengo un organillo de juguete que uso a veces para sacar las canciones de oido. Toco la guitarra pero como no soy un portento veo mejor las notas sobre un teclado. Últimamente, por falta de tiempo, tampoco le dedico demasiadas horas, así que se me agotan las baterias. El aparato en cuestión tiene una toma para un alimentador a 7.5 voltios en continua. Así que he rebuscado en el desván y he encontrado un adaptador (ya no me acuerdo de qué) que pasa 220v ac a 12v ac. Lo destripo y ya tengo el transformador...


Tengo un transformador con el que consigo 12v en alterna. Necesito conseguir 7.5 v en continua, con el positivo en el exterior del conector y negativo en el agujerito... El transformador me da 300mA como maximo. Y hay un pequeño problema: tengo un regulador de tension de 6v(lm7806) y otro de 8 (lm7808) pero no de 7,5... Vamos a ponerle el de 6v para no pasarnos. Usaré una fuente esterna para ver como funciona y cuanto consume con 6v.



Recordad que para medir la intensidad debemos colocar el amperímetro en serie, "dentro" del circuito que queremos medir.
Si aplico 6v a la entrada el organillo consume unos 70mA. Si aplico 8v, a todo volumen y funcionando con todas las teclas que puede reproducir (6 en mi caso), y con los ritmos puestos..., consume un poco más de 100mA. Esto indica que el transformador de 300mA es valido, de sobra, para el proyecto.


Destripamos entonces el transformador e iré probando el circuito que pretendo montar.

Para hacer pruebas tendré en cuenta lo siguiente: la intensidad máxima que puede soportar el transformador es de 300mA; la tensión eficaz que suministra es 12V. Así que la resistencia mínima que se puedo poner en la carga es de 40 ohmios (Por ley de ohm R=V/I, 12v/0.3A=40ohm). Si la resistencia es menor, aumentará la intensidad suponiendo que el transformador todavía sea capaz de suministrar los 12v...
Busco, entonces, la resistencia de valor más parecido (39ohmios) y más "gorda" (que soporte más potencia) que tengo, y la coloco como carga y mido lo que suministra el transformador.

En extremos de la carga tenemos una señal alterna de frecuencia 49,97hz (los 50hz de la red), valor medio en continua 0v (lógico si es alterna), de pico a pico 31,60v, y valor eficaz 11,09 (los 12v que debería dar el transformador, téngase en cuenta que estamos a tope de consumo con una resistencia de 39ohmios).
Empezaremos pues por rectificar. He optado por un simple diodo (1N4007 lo tenía por casa es muy común) como rectificador de media onda, por que es sencillo, y si rectifico a doble onda conseguiré más voltaje de valor medio. No me interesa hacercarme a los 12v eficaces si el integrado que voy a poner es para 6v. Probarémos con media onda:



Y aquí está lo que conseguimos: frecuencia=49.99hz (50hz); valor medio continua=4.600v; valor de pico a pico=15.72v; y valor eficaz alterna=7.497v

Y ahora vendría el filtrado. También por cuestiones de espacio, pondré el filtro más simple un simple condensador de algo más de los voltios que vamos a conseguir. En casa tengo uno de 25v y 470uF. Ahora el condensador devuelve la carga en los espacios que había sin tensión y aumenta el valor medio de la tensión en continua. Para conseguir los 6v finales debemos tener algo más ahora. Los 9v que indica el osciloscopio es perfecto.


Las medidas que indica el osciloscopio son: Frecuencia=50.22hz; Tensión media en continua 9v; Tensión de pico a pico 7.320v; Tensión eficaz 9.265v

Las cosas van saliendo bien. Ahora sólo nos queda eliminar ese rizado de alterna.

Para estabilizar es comodísimo usar un integrado. Tenemos 9voltios así que la cosa debe funcionar con cualquier regulador de tensión LM780x que estabilice a un poco menos de los 9 voltios. El regulador que usemos debería alimentarse, según el fabricante (busqueda en la web por "LM7806 datasheet"),a unos 2.5v más que la tensión a la que queremos regular. 6+2.5=8.5v y nosotros tenemos 9v así que perfecto. Podríamos poner un LM7805 para conseguir 5v perfectos, o un LM7806 para 6v, que es lo que yo estaba pensando, e incluso me arriesgaría con un LM7808 para los 8v a ver que pasa...




En la foto vemos el montaje un poco chapuzero de todo el tringlado, con un LM7806. La patilla 2 (la del medio) es la masa común. La patilla 1 (izquierda leyendo la serigrafía) es la entrada. La patilla 3 (derecha) es la salida.


Y..., ¡bingo!. Tenemos señal de 6v continua:
Frecuencia=? (es continua claro); Valor medio continua=6v clavados; Tensión de pico a pico 720.0mV (rizado casi nulo); Valor eficaz=6.151v.


Creo que cumple mis expectativas perfectamete asi que lo vamos a montar...
Finalmente lo montaré con un LM7808. He descubierto, que una caja de ritmos vieja, que tengo por casa, tiene el conector de la misma forma y va a 9v. Asi que, con los 8v, creo que me va a servir para el organillo y para la caja de ritmos...



Aquí se ve un esquema del adaptador antes y después de la modificación.


Y poco más hay que explicar de los detalles del montaje...Meter todo como se pueda. Use un recorte de una placa de esas perforadas. Y por si acaso meto un aislante entre el transformador y la placa.