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:

Y sin desplacamiento:

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

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í.

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.

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.

Auriculares para radiodespertador

Para repasar: asociación de resitencias, serie, paralelo, ley de ohm.

Holas a todos de nuevo.
No se trata de nada complicado, pero como ya lo he hecho en varias ocasiones y me parece útil, esta vez he decidido colgar aquí la última operación.
Se trata de montar una toma para escuchar con auriculares algo que generalmente escuchas por los altavoces del aparato. En este caso es un radiodespertador, para escuchar la radio por la noche y no molestar al acompañante o para compartir. No he montado un auricular sino una cajita con un minialtavoz. Así puedes ponerla al lado de la oreja, sobre la almohada, debajo,... en donde menos moleste y no perjudicar los oidos con el auricular. Otras veces lo he hecho en una TV para ver pelis por la noche sin molestar a los que duermen...
La idea la intento definir en el esquema de la 1ªfigura:






La idea es poner una toma jack que al meter el jack macho abre el circuito que envia la señal al altavoz original. Con esto el altavoz deja de funcionar y la señal original será enviada a los auriculare o en este caso en concreto una cajita con el altavoz que pondremos al lado de la oreja. Numero los pines para que correspondan con el esquema. Observa que es importante que la señal vaya al terminal 2 y no al 3 para que el audio conecte con el vivo del jack.



Esta es una idea de como era el radiodespertador antes de la modificación. Estuidiamos en donde podemos agujerear para colocar el jack hembra.



Y en esta cuarta fotografía trato de clarificar los puntos a y b del esquema que es en donde tenemos la señal original del altavoz. También debemos observar que el altavoz original es de 16 ohmios (cosa rara, suele ser de 4 u 8). Unos auriculares tienen una impedancia mayor asi que no habrá problema con el amplificador del aparato. Más resistencia implica menor intensidad y menor potencia: menos volumen, pero el amplificador no sufrirá.








Pero en el caso nuestro, enchufaremos un altavoz de 8 ohmios (que es el que tengo por casa). Esto podría forzar el amplificador. Mitad de resistencia implica que el ampli deba suministar el doble de intensidad. (Ley de ohm: R=V/I) Así que "por si las moscas" añadiremos una resistencia (de 8,2 ohmios) en serie al altavoz de 8 ohmios y tendremos los 16 que tenía el altavoz original

El altavoz o auricular que enchufemos no deberá bajar de la resistencia o impedancia del altavoz original. Distorsionará y corremos riesgo de quemar la etapa de amplificación. Ante la duda que sea de mayor resistencia, perderemos potencia (nada importante para escuchar algo pegado al oido) pero conservaremos calidad y nuestro aparato. .



Recordando la asociacion de resistencias. En serie Rtotal=R1+R2+... En paralelo 1/Rtotal=1/R1+1/R2+1/R3+...

Luego protejo la resistencia con manguera retráctil para asigurarme que no haya contactos peligrosos, y meto mi altavoz en una cajita de cartón que da el grueso del altavoz perfectamente con lo que no se mueve y anudo el cable para prevenir tirones...


Y nada. Espero haberos dado alguna idea. Aquí os muestro el resultado final que por cierto va perfectamente.