Fuente SMPS desde una pila de 1.5V

En esta nota, les traeré un circuito muy simple que he realizado en varias versiones y todas con buenos resultados. Es una fuente SMPS del tipo Booster (Step-Up) que en un principio fue pensada para alimentar un led de alta luminosidad a partir de una pila de 1.5V.
En la red circulan muchos circuitos de este tipo con el nombre de "ladrón de julios" (Joule thief), pero en realidad aquí no hay ningún robo, es decir, lo denominan así porque la idea es que, dicen, robar energía (Joules), pero como sabemos aquí no se roba nada, sino que se transforma. De echo me he topado con muchos vídeos y muchas paginas que dicen que es energía libre y demás atrocidades sobre una simple fuente SMPS Booster basado en un oscilador de bloqueo.
En este caso yo he implementado dos tipos diferentes, la mas usual que es la fuente de un único transistor con re-alimentación por transformador, es decir, la configuración básica donde tenemos un choque (bobina sobe núcleo ferromagnético) y esta bobina es obligada a oscilar mediante el corte y la saturación de un transistor.
Hasta aquí es lo normal, pero la diferencia en los dos circuitos que realice es en el método para excitar la base de este transistor.
En el primer caso podremos ver que el colector del transistor se conecta a un transformador que no se encuentra aislado ya que se unen los devanados en el positivo. o bien podría ser una bobina con toma central o un auto-transformador.
Notamos que tenemos 15 espiras para el devanado controlado por el transistor y 5 espiras para el otro devanado que se encuentra en serie con el anterior, entonces lo que hace esta bobina de 5 espiras es tomas parte del campo magnético generado y re-alimentarlo a la base del transistor para que el circuito se torne inestable por re-alimentación positiva y se convierta en un oscilador, de esta forma se auto ajusta la frecuencia en función de los parámetros físicos de diseño de la bobina y demás componentes.
En mi caso he implementado una resistencia de 330R 1/4W (Resistencia a la que he llegado utilizando un potenciometro para analizar el mayor rendimiento) y en paralelo un capacitor cerámico de 180pF, este es para que varié su reactancia y el valor de la resistencia sea dinámico en función del arranque del circuito.
Por ultimo podremos ver que en paralelo al transistor tenemos un LED que en realidad funciona como rectificador también pero el mismo se iluminara en función de la tensión nominal del led, esto es porque la potencia de la fuente no es lo suficiente como para que la corriente pueda dañar el led y por no poseer carga en un capacitor.


En esta otra versión del circuito podremos ver que le he eliminado el LED y en su lugar incorpore un diodo de conmutación 1N4148 y un capacitor electrolítico de 1uF/100V, en este caso la fuente funciona correctamente como lo hace cualquier SMPS pero hay que tener en cuenta que esta fuente SMPS no tiene re-alimentación de la salida por lo que es una fuente "libre" y la tensión de salida se incrementara hasta donde los componentes se lo permitan, al incorporar un capacitor en la salida del diodo tendremos una pequeña acumulación de corriente que nos proporcionara una potencia algo mayor que en el primer circuito por lo que en este caso no es recomendable poner el led sin resistencia.
En mi practica he llegado a los 110V y 2mA en su salida.
Por ultimo la otra versión de este circuito no requiere de re-alimentación de transformador, es decir ya no se requieren dos devanados o uno con toma central, sino que se utiliza un solo de choque y en cambio se incorpora un segundo transistor que toma una muestra de la señal de salida del transistor de conmutación y la ingresa mediante la adaptación RC a la base del transistor de disparo que por su configuración de emisor común funcionara como inversor, y a la salida de este en su colector acoplamos la base del transistor de conmutación, dando como resultado una re-alimentación.

NOTA: El transformador o auto-transformador, se ha realizado a mano en una forma toroidal de 10mm de diámetro exterior con 6mm de diámetro interior y 4mm de altura, se ha utilizado cobre del tipo 22AWG (aproximadamente 0.6mm).
En el segundo circuito donde no usamos transformador y es solo un choque, se ha utilizado un choque comercial de 100uHy.

RENDIMIENTO: El circuito no me ha dado mas de un 60% de rendimiento, en función de la potencia que puede erogar y la potencia que extrae de la pila, por lo que no es de lo mejor, puede servir para sacarnos de apuro, pero no tiene el mejor rendimiento.

Matriz 8x8 con motivo de Navidad

Hola, hoy estaré realizando una actualización a la matriz de led 8x8 que posiblemente ya conozcan de mis otros post http://electgpl.blogspot.com.ar/2013/11/matriz-8x8-mensaje-con-desplazamiento.html
En este caso, no hay nada nuevo, solo he agregado unas secuencias de animación, texto scroll y dibujos estáticos.
La idea era montarla en el árbol navideño junto a unas tiras de led RGB para hacer una navidad mas tecnológica.
Me queda como pendiente (aunque no tengo demasiado tiempo para ello) realizar una función audioritmica a esta matriz que realice figuras geometrías o algo asimilar en función del nivel de ruido ambiente, para aprovechar el resto de los pines y los canales analógicos de este microcontrolador PIC16F883.
En este caso el hardware es super simple, realizado a la mínima cantidad de componentes y alimentado con 3V a partir de dos pilas AA.
NOTA: el pack de 8 resistencias de 220 Ohms porque esta funcionando con 3V, si lo hacen funcionar con 5V deben aumentar a 470 Ohms para no sobrecargar las salidas del puerto.
O bien lo ideal podría ser poner inmediatamente a la salida de cada puerto (el A y el C) 8 resistencias de 220 o dejar solo un pack de 8 para un puerto y poner 8 diodos de conmutación 1N4148 para que la corriente cuando una salida es 1 y la otra 0 no vuelva al mismo puerto. Son algunas precauciones, pero igual si ponen el valor de resistencia adecuada no tendrán problemas eléctricos.
También he aprovechado el puerto B para poner un puerto ICSP y poder programar en circuito a este microcontrolador, por dos motivos, el primero es que las secuencias de la matriz suelen modificarse a menudo para probar cual queda mejor, y es un poco tedioso sacar el microcontrolador del zócalo y el otro motivo es que por el tamaño de este microcontrolador PDIP se me ocurrió realizarlo en encapsulado SOIC para que ocupe menos espacio, y siempre que utilicen SOIC es mas sencillo programarlo por ICSP.




Ahora hablaremos del programa, pero para ello primero lo presentare aquí.

  1. #include <16F883.h>
  2. #use delay(int=4000000)
  3. #define LARGO_FN 79                                //Longitud de Frase de Navidad
  4. int const FelizNavidad[LARGO_FN+16]={              //Vector de Frase de Navidad
  5. 0,0,0,0,0,0,0,0,                                   //    8 espacios          
  6. 0x7F, 0x09, 0x09, 0x01, 0x01, 0x00,                // F
  7. 0x38, 0x54, 0x54, 0x54, 0x18, 0x00,                // e
  8. 0x00, 0x41, 0x7F, 0x40, 0x00, 0x00,                // l
  9. 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,                // i
  10. 0x44, 0x64, 0x54, 0x4C, 0x44, 0x00,                // z
  11. 0x00, 0x00, 0x00,                                  //    3 espacios
  12. 0x7F, 0x04, 0x08, 0x10, 0x7F, 0x00,                // N
  13. 0x20, 0x54, 0x54, 0x54, 0x78, 0x00,                // a
  14. 0x1C, 0x20, 0x40, 0x20, 0x1C, 0x00,                // v
  15. 0x00, 0x44, 0x7D, 0x40, 0x00, 0x00,                // i
  16. 0x38, 0x44, 0x44, 0x48, 0x7F, 0x00,                // d
  17. 0x20, 0x54, 0x54, 0x54, 0x78, 0x00,                // a
  18. 0x38, 0x44, 0x44, 0x48, 0x7F, 0x00,                // d
  19. 0x00, 0x5F, 0x00, 0x00,                            // !
  20. 0,0,0,0,0,0,0,0,                                   //    8 espacios  
  21. };
  22. int const ArbolNavidad[8]={                        //Vector del dibujo Arbol
  23. 0x20, 0x30, 0x3C, 0xFF, 0xFF, 0x3C, 0x30, 0x20
  24. };
  25. int const EstNavidad[16][8]={                      //Vector animado
  26. {0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81},
  27. {0x02, 0xc2, 0x24, 0x18, 0x18, 0x24, 0x43, 0x40},
  28. {0x04, 0x42, 0xa4, 0x18, 0x18, 0x25, 0x42, 0x20},
  29. {0x08, 0x04, 0x64, 0x98, 0x19, 0x26, 0x20, 0x10},
  30. {0x30, 0x08, 0x25, 0x59, 0x9a, 0xa4, 0x10, 0x0c},
  31. {0xe1, 0x11, 0x09, 0x3a, 0x5c, 0x90, 0x88, 0x87},
  32. {0x06, 0xf2, 0x8a, 0x3a, 0x5c, 0x51, 0x4f, 0x60},
  33. {0x08, 0x34, 0x4a, 0xba, 0x5d, 0x52, 0x2c, 0x10},
  34. {0x00, 0x18, 0x3c, 0x7e, 0x7e, 0x3c, 0x18, 0x00},
  35. {0x00, 0x3c, 0x34, 0x3c, 0x3c, 0x34, 0x3c, 0x00},
  36. {0x78, 0x3c, 0xf7, 0x3c, 0x3c, 0xf7, 0x3c, 0x78},
  37. {0x1e, 0xbc, 0x77, 0x3c, 0x3c, 0x77, 0xbc, 0x1e},
  38. {0x78, 0x3c, 0xf7, 0x3c, 0x3c, 0xf7, 0x3c, 0x78},
  39. {0x1e, 0xbc, 0x77, 0x3c, 0x3c, 0x77, 0xbc, 0x1e},
  40. {0x78, 0x3c, 0xf7, 0x3c, 0x3c, 0xf7, 0x3c, 0x78},
  41. {0x1e, 0xbc, 0x77, 0x3c, 0x3c, 0x77, 0xbc, 0x1e}
  42. };
  43. byte const bitMask[8]={1,2,4,8,16,32,64,128};      //Mascara
  44. int i,j,k,x;                                       //Variables contadores
  45. void fraseNavidad(int1 Neg){
  46.    for(i=0;i<LARGO_FN+8;i++){                      //Recorrido de tabla
  47.       for(k=0;k<20;k++){                           //Refresco de matriz
  48.          for(j=0;j<8;j++){                         //Barrido de columnas
  49.             output_a(~bitMask[j]);                 //Columnas ponderadas
  50.             if(Neg)                                //Negativo
  51.                output_c(~FelizNavidad[j+i]);       //Desplazamiento de tabla
  52.             else                                   //Directo
  53.                output_c(FelizNavidad[j+i]);        //Desplazamiento de tabla
  54.             delay_us(500);                         //Demora de multiplexado
  55.          }  
  56.       }
  57.    }
  58. }
  59. void animNavidad(){
  60.    for(i=0;i<16;i++){                              //Cambia de subVector
  61.       for(k=0;k<30;k++){                           //Persistencia
  62.          for(j=0;j<8;j++){                         //Barrido de columnas
  63.             output_a(~bitMask[j]);                 //Columnas ponderadas
  64.             output_c(EstNavidad[i][j]);            //Desplazamiento de tabla
  65.             delay_us(600);                         //Demora de multiplexado
  66.          }  
  67.       }
  68.    }
  69. }  
  70. void dibujoArbol(int1 Neg){
  71.    for(k=0;k<50;k++){                              //Persistencia
  72.       for(j=0;j<8;j++){                            //Barrido de filas y columnas
  73.          output_a(~bitMask[j]);                    //Columnas ponderadas
  74.          if(Neg)                                   //Negativo
  75.             output_c(~ArbolNavidad[j]);            //Desplazamiento de tabla
  76.          else                                      //Directo
  77.             output_c(ArbolNavidad[j]);             //Desplazamiento de tabla
  78.          delay_us(700);                            //Demora de multiplexado
  79.       }  
  80.    }  
  81. }
  82. void main(){    
  83.    while(TRUE){                                    //Funcion Principal Repetitiva
  84.       for(x=0;x<3;x++){                            //Arbol de Navidad 3 veces
  85.          dibujoArbol(FALSE);                       //Arbol de Navidad
  86.          dibujoArbol(TRUE);                        //Arbol de Navidad Invertido
  87.       }
  88.       fraseNavidad(FALSE);                         //Frase de Navidad
  89.       for(x=0;x<3;x++){                            //Arbol de Navidad 3 veces
  90.          dibujoArbol(FALSE);                       //Arbol de Navidad
  91.          dibujoArbol(TRUE);                        //Arbol de Navidad Invertido
  92.       }
  93.       for(x=0;x<3;x++){                            //Animacion de Navidad 3 veces
  94.          animNavidad();                            //Animacion de Navidad
  95.       }      
  96.       fraseNavidad(TRUE);                          //Frase de Navidad Invertida
  97.    }
  98. }

Bueno lo primero que notamos a primera vista es que hay mucho vector con variables de 8 bit, esto es porque la matriz es de 8x8 y realizamos grupos de 8 variables de 1byte para conformar los 64 puntos de la matriz.
Para realizar los dibujos y letras he utilizado una matriz virtual online que permite encender y apagar cada punto y automáticamente genera el código en hexadecimal y binario.

El programa principal mantiene el llamado a varias funciones que cada una realiza una secuencia o animación diferente en la matriz, como pueden ver, alguna de ellas poseen lazos de iteracion for para llamar la función varias veces (todo esto es customizable por el desarrollador).
Lo principal son las funciones que hablaremos ahora:

La función fraceNavidad(); es una función que llama al vector "FelizNavidad" que el mismo posee la frase "Feliz Navidad!", el proceso para el multiplexado y scroll lo pueden ver en el post de la matriz de 8x8 que he dejado al principio. Luego la función tiene como argumento una variable de 1bit que cumple la función de flag, es decir puede estar en true o en false, y este estado tiene acción en un if dentro de esta función que lo que hace es agregar en el vector el símbolo ~ que invierte el valor que lee en el vector, es decir si decía 00001100 al invertirlo dirá 11110011, esto hace que podamos ver la frase en negativo.

La función animaNavidad(); es una función similar a la anterior pero en esta no se produce el efecto de scroll ya que no hay texto que leer, pero en cambio se utiliza un vector de dos dimensiones "EstNavidad" que posee cada registro de 8 variables de 8 bit para realizar diferentes "dibujos" o "animaciones" en la matriz, el for de iteracion va recorriendo cada variable de 8 bit de cada por cada registro para formar el dibujo.

La función dibujoArbol(); es la función mas sencilla, ya que solo tiene un registro para dibujar un árbol o pino de navidad y al igual que la función de texto posee la inversión a negativo del dibujo para darle un efecto extra.