Fuente SMPS con MC34063

Este integrado, es un conversor DC/DC StepUP, StepDown o Inversor de tensión, es decir, puede funcionar como fuente elevadora de tensión, reductora de tensión o bien inversora de tensión.
En este caso se utilizara la configuración elevadora de tensión que es la que realice en la práctica ya que necesitaba extraer 12V a partir de 5V, en este blog van a encontrar otras fuentes similares con el integrado LM2577 o 555, ambas funcionan bien, la que utiliza el 2577 es integrada de potencia pero es la mas costosa por el integrado que utiliza. La que utiliza el timer 555 es la más barata y configurable pero carece de realimentaciones y pwm, etc.…. Por ultimo la que menciono en ese post es similar a la del 2577 pero no es de potencia, es decir, el integrado 34063 solo proporciona 100mA en su salida como máximo pero es posible aumentar esa potencia con un transistor externo, de esta forma le he podido extraer 200mA sobre 12V, lo cual nos permite alimentar algunos dispositivos de baja señal.
Nótese que he mencionado que solo le extraje 200mA esto es porque esta alimentado con el puerto USB, el cual según normas IEEE nos proporciona unos 500mA como estándar en notebooks y desktops por lo que la limitación esta en el USB, si en cambio lo alimentáramos con 6V desde 4 pilas podríamos extraer mas potencia de salida con ese transistor.
El calculo del choque de RF lo dejare para otro post ya que no viene al caso, la bobina L1 esta construida en un núcleo toroidal de 20mm de diámetro exterior y 15mm de diámetro interior, en el cual se arrollan 20 vueltas de alambre AWG 20 (0,8mm), de esta forma su inductancia ronda los 100uHy claramente se puede comprar el choque ya construido.
La tensión de salida de esta fuente será función de la realimentación del integrado que ingresa por el pin #5 en su interior hay un comparador en donde el mismo integrado posee una tensión de referencia de 1,25V, por ende compara la tensión ingresada en el pin #5 con los 1,25V internos, nótese que si la tensión en este pin es menor a 1,25 la fuente aumentara el ciclo útil del pwm para enviar mayor tensión a la salida, lo mismo pasa en el caso contrario, si la tensión en el pin #5 es mayor a la de referencia reducirá la salida de tensión.
Entonces tendremos que jugar con estos valores de R3 y R4 para lograr la tensión de salida deseada.
El calculo para la tensión en la entrada del comparador es 1,25(1+(R4/R3)).




Matriz de LED con RTOS

En este nuevo proyecto, se ha tomado como base el proyecto de http://electgpl.blogspot.com.ar/2012/05/control-de-matriz-estatica.html al cual se ha modificado para que funcione con RTOS, como vimos en la introducción a RTOS http://electgpl.blogspot.com.ar/2012/12/rtos-sistema-operativo-en-tiempo-real.html ahora se le quito la interrupción por desbordamiento del TIMER0 y directamente se realizaron dos tareas que correrán mediante el sistema operativo, la primera tarea se encargara de sensar las columnas o multiplexar las columnas y la segunda tarea se encargara del barrido de caracteres, si bien ambas funciones tienen que funcionar a una velocidad tal que no se detecten parpadeos en la matriz, nótese que la tarea del barrido de caracteres posee un tiempo de 30ms (30 veces mas lenta que la tarea de multiplexado), de esta forma se logra ver el movimiento de los caracteres formando la palabra "ELECTGPL".
El circuito es el mismo que se ha utilizado en la versión sin RTOS, y el único cambio es el mencionado sistema operativo, el cual nos ha dado mejores resultados tras la ejecución.



El código fuente es el siguiente:

#include<16F883.h>
#use delay(int=4000000)
#fuses XT,NOWDT


#use rtos(timer=0,minor_cycle=1ms)


//Definicion de variables
int fila[5],letra=0;


//Definicion de la primera tarea (sensado de columnas)
#task(rate=1ms,max=1ms)

void funcion1();
 

//Definicion de la segunda tarea (barrido de caracteres)
#task(rate=30ms,max=1ms)
void funcion2();
 

//Inicio del programa
void main(){
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4);
   rtos_run();
}


//Funcion de sensado de columnas
void funcion1(){
   output_a(0b00000001);
   output_c(~fila[0]);
   delay_ms(10);
   output_a(0b00000010);           
   output_c(~fila[1]);
   delay_ms(10);
   output_a(0b00000100);           
   output_c(~fila[2]);
   delay_ms(10);
   output_a(0b00001000);           
   output_c(~fila[3]);
   delay_ms(10);
   output_a(0b00010000);
   output_c(~fila[4]);
   delay_ms(10);
}


//Funcion de muestreo de caracteres
void funcion2(){
   switch(letra){
      case 0: fila[0]=0b01000001;
              fila[1]=0b01000001;
              fila[2]=0b01001001;
              fila[3]=0b01001001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 1: fila[0]=0b00000001;
              fila[1]=0b00000001;
              fila[2]=0b00000001;
              fila[3]=0b00000001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 2: fila[0]=0b01000001;
              fila[1]=0b01000001;
              fila[2]=0b01001001;
              fila[3]=0b01001001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 3: fila[0]=0b01000001;
              fila[1]=0b01000001;
              fila[2]=0b01000001;
              fila[3]=0b01000001;
              fila[4]=0b00111110;
              letra++;
              break;
      case 4: fila[0]=0b01000000;
              fila[1]=0b01000000;
              fila[2]=0b01111111;
              fila[3]=0b01000000;
              fila[4]=0b01000000;
              letra++;
              break;
      case 5: fila[0]=0b00000110;
              fila[1]=0b01001001;
              fila[2]=0b01001001;
              fila[3]=0b01000001;
              fila[4]=0b00111110;
              letra++;
              break;
      case 6: fila[0]=0b00110000;
              fila[1]=0b01001000;
              fila[2]=0b01001000;
              fila[3]=0b01001000;
              fila[4]=0b01111111;
              letra++;
              break;
      case 7: fila[0]=0b00000001;
              fila[1]=0b00000001;
              fila[2]=0b00000001;
              fila[3]=0b00000001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 8: fila[0]=0b00000000;
              fila[1]=0b00000000;
              fila[2]=0b00000000;
              fila[3]=0b00000000;
              fila[4]=0b00000000;
              letra = 0;
              break;
   }       
}


Multiple I2C Virtual

Al igual que el puerto serial se puede utilizar el comando STREAM para definir el nombre de los puertos.
Comúnmente para un solo puerto configuramos el mismo de la siguiente forma:

#use i2c(MASTER,SDA=PIN_C1,SCL=PIN_C0)

De esta forma se define el protocolo, puertos, etc...
Luego se procederá a enviar o recibir el dato por i2c por ejemplo:

i2c_start();
i2c_write(DATO);
i2c_write(DATO);
i2c_write(DATO);
i2c_stop();


Donde iniciamos el protocolo tras la función i2c_start(); y luego escribimos los byte correspondientes según necesite el dispositivo a comandar mediante la función i2c_write(); y luego se procede a cerrar el protocolo con la función i2c_stop();.

Si quisiéramos incluir otro puerto i2c en el microcontrolador deberíamos utilizar el comando STREAM el cuál nos indicara una etiqueta para la configuración del puerto y esta misma será la que utilizamos para diferenciar entre un protocolo o el otro.

#use i2c(MASTER,SDA=PIN_C1,SCL=PIN_C0,STREAM=I2C1)
#use i2c(MASTER,SDA=PIN_B1,SCL=PIN_B0,STREAM=I2C2)


Donde podemos ver que en el primer puerto será STREAM=I2C1 y el segundo puerto será STREAM=I2C2. El comando dentro de las funciones start, write y stop quedara de la siguiente forma.

i2c_start(I2C1);
i2c_write(I2C1,DATO);
i2c_write(I2C1,DATO);
i2c_write(I2C1,DATO);
i2c_stop(I2C1);

i2c_start(I2C2);
i2c_write(I2C2,DATO);
i2c_write(I2C2,DATO);
i2c_write(I2C2,DATO);
i2c_stop(I2C2);


Tener en cuenta que el protocolo I2C del MCU por Hardware será uno solo, esta forma de crear puertos es netamente virtual por ende los tiempos del procesador será más lento, es recomendable para procesadores de gama media alta.

Multiple UART Virtual



Como utilizar mas de un puerto de comunicación serial.
No es de lo más común pero es posible que se quieran utilizar más de un puerto serial en el mismo micro.
Comúnmente para un solo puerto configuramos el mismo de la siguiente forma:

#use RS232(BAUD=9600, XMIT=PIN_C1, RCV=PIN_C2,FORCE_SW)

De esta forma le decimos la velocidad y los pines que utilizaremos como TX y RX, luego para enviar un dato por serial utilizamos la función printf(); por ejemplo:

printf(“VALOR1: %d\n”,valor1);

donde mostramos el valor1 en la salida serial.
Ahora si queremos incluir otra salida serial podríamos hacerlo de la siguiente forma:

#use RS232(BAUD=9600, XMIT=PIN_B1,RCV=PIN_B2,FORCE_SW)

Aquí vemos que es igual a la otra forma pero cambiamos los pines C1 y C2 por B1 y B2, pero hay algo que sigue quedando mal, cuando llamemos a la función printf(); para que nos muestre el valor2 será:

printf(“VALOR2: %d\n”,valor2);

pero esto por que puerto saldrá? Bueno aquí esta la diferencia, para que podamos incluir mas de un puerto de transmisión debemos incluir en su configuración la directiva STREAM donde la igualaremos al nombre del puerto, por ejemplo: STREAM=SERIAL1, ahora ambas directivas quedaran de la siguiente forma:

#use RS232(BAUD=9600, XMIT=PIN_C1,RCV=PIN_C2,FORCE_SW,STREAM=SERIAL1)
#use RS232(BAUD=9600, XMIT=PIN_B1,RCV=PIN_B2,FORCE_SW,STREAM=SERIAL2)

Y para terminar esto los llamados a la función printf(); quedaran:

fprintf(SERIAL1,"VALOR1: %d\n”,valor1);
fprintf(SERIAL2,"VALOR2: %d\n”,valor2);

Y esto se repetirá según la cantidad de puertos a utilizar.

Tener en cuenta que el protocolo SPI/EUSART del MCU por Hardware será uno solo, esta forma de crear puertos es netamente virtual por ende los tiempos del procesador será más lento, es recomendable para procesadores de gama media alta.

RTOS - Sistema Operativo en Tiempo Real



RTOS, Sistema Operativo en Tiempo Real (Real Time Operating System).
Como lo dice su nombre es un sistema operativo en tiempo real, para que sirve?, sencillo supongamos que necesitamos realizar tareas múltiples (Multi Tasking) como por ejemplo Leer un puerto, mientras enviar datos por serie, mientras realizar cálculos, mientras mostrar mensajes en un LCD, etc… Todo esto al mismo tiempo. Sabemos que por ejemplo cuando leemos el canal ADC este mismo funciona por interrupción, es decir, cuando termina la lectura nos permite volcar su dato a una variable, esto demora un tiempo que se puede setear pero supongamos que el tiempo que demora es 200ms, el resto del microcontrolador estará inactivo 200ms hasta que el ADC envíe el valor y devuelva el control al programa principal, si por ejemplo realizáramos otras tareas mientras transcurren esos 200ms?, es aquí donde entra el RTOS, no es mas que un kernel multiplataforma que en este caso sobre CCS para PICmicro nos permite optimizar el tiempo y el procesador, de esta forma nuestro procesador se vuelve mas eficiente y podemos sacarle el mayor provecho.
La forma de funcionar de este RTOS es muy sencilla se basa en algunas directivas y funciones las cuales no comentare todas porque seria muy extenso pero si les comentare las mas comunes y sencillas.
La estructura es la siguiente:

1) Se inicializa el RTOS
#use rtos(timer = 0, minor_cycle = 100ms)

2) Las tareas a realizar puede ser una o más de una
#task(rate=100ms,max=100ms)

Solo con estas dos funciones podemos implementar en nuestro programa un RTOS.

Detalle:
#use rtos(timer = 0, minor_cycle = 1ms)
Esto nos dice que usaremos rtos mediante el timer0 y con un tiempo mínimo de ejecución de cada tarea de 1ms

#task(rate=1s,max=100ms)
Esto nos dice que usaremos una task (tarea) que se ejecutara cada 1s y que como máximo la ejecución tardara 100ms.

Estos valores pueden ser diferentes, va en función de la necesidad de cada tarea.

Un ejemplo de utilización en código C (CCS)

#include<rtos.h>
#use rtos(timer = 0, minor_cycle = 1ms)
#task (rate=1s, max=10ms) //Ejecuta cada 1 segundo, dura máximo 10ms  
void func1();//Llama a la función func1();
#task (rate=2s, max=10us) //Ejecuta cada 2 segundos, dura máximo 10us  
void func2();//Llama a la función func2();

main(){
 
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4); //TMR0 para el RTOS
   rtos_run();//Función que ejecuta el RTOS
}  
void func1(){  
   printf("Ejecuta primera task\n");  
}  
void func2(){
   printf("Ejecuta segunda task\n");  
}

Bueno esta es la forma de utilizar RTOS, nótese que se utilizaron dos funciones donde dentro de ellas se puede poner la tarea que uno quiera, pero podrían haber sido mas de dos tareas, o bien también puede no utilizarse funciones y se puede incluir el código directamente de bajo de la definición de las tarea del rtos.

A este programa le faltan las directivas del microcontrolador que utilizaran en su proyecto, como librería, configuraciones, etc… Es solo a modo informativo de cómo se utiliza el RTOS.

NOTA: existen otras funciones mas específicas como para interrupciones especiales, o retornos de datos según el funcionamiento, es posible configurar las task por ejemplo para que nos devuelva un valor si la tarea fue realizada correctamente o no, entre otras cosas.

Conversor USB UART TTL


Conversor de protocolo usb a serial, este proyecto se basa en el integrado MCP2200 de microchip, el cual solo requiere de unos pocos componentes externos para funcionar.

En la pagina de microchip cuando buscamos este integrado también nos ofrecen los drivers para Windows y Linux, de esta forma solo resta conectar el integrado y enchufarlo en el usb de la pc. 

Una vez que este conectado a la pc nos pedirá el driver que es el que bajamos de la pagina de microchip, y rápidamente lo tendremos funcionando.

Para que nos sirve?,  sencillo nos crea un puerto COM virtual por medio del USB., es decir nos aparecerá un puerto COM en la pc, por el cual podremos enviar y recibir datos serial por ejemplo con un micro controlador, modulo bluetooth, etc… También es posible acoplar un MAX232 y convertir esta salida serial en la norma RS232, para manejar dispositivos que la requieran o algún programador de microcontrolador, por ejemplo podríamos actualizar nuestro programador serial de micros a conexión usb y poder utilizarlo en cualquier pc que no tenga este antiguo puerto.

Con el tema de la configuración de este integro podemos dejarlo asi como viene de fabrica, o bien utilizar una herramienta que descargamos del mismo lugar de donde descargamos el driver, MCP2200 Configuration Utility que es para configurar el integrado, por ejemplo habilitar los pines RTS, CTS, habilitar los leds de RX y TX, cambiar el nombre del fabricante y empresa, etc…

En este link podemos descargar los driver y soft:

NOTA: el integrado en este proyecto se encuentra en encapsulado SOIC (de montaje superficial) no he podido conseguir en DIP.





Transmisor de AM

Este transmisor es de frecuencia fija, ya que se trata de simplificar al máximo el circuito para que se comprenda el funcionamiento de una transmisión en amplitud modulada.
Para comprender mejor esta idea teórica la siguiente imagen muestra las tres etapas de la señal, que casualmente son las tres etapas del circuito.
Primero observamos la señal a modular o el dato, es la señal que nos interesa transmitir, por ejemplo audio, en este caso es una función senoidal para no complicar la idea.
Luego observamos una señal senoidal también pero de menor periodo o de mayor frecuencia, esta es la señal portadora, es donde se montara la señal "Dato" para que pueda ser transmitida, ya que en comunicaciones si una señal no oscila lo suficiente mente rápido se romperá el dato, por ejemplo si transmitimos sonido a 8kHz, y la portadora es de 1kHz no servirá esta transmisión porque la señal dato tiene mayor frecuencia que la portadora, la idea es que mientras mas ancho de banda tenga la señal dato, mas rápido que ella deberá ir la portadora, un ejemplo simple, el sonido en AM viaja mono y con una calidad PCM de 5 o 6kHz, por eso podemos montarla en una portadora de 1MHz como sucede en la AM comercial, ahora si pasamos a la FM comercial notoriamente la calidad de audio aumenta y también sus canales por eso elevamos esta calidad y por consiguiente la portadora estamos hablando de 100MHz, y si nos vamos mas arriba para transmitir una señal de Internet donde se transfieren mucha cantidad de datos teniendo en cuenta que mientras mas rápido se transfieran mas rapido abriremos la pagina que queremos ver, necesitamos algo mas de frecuencia por ejemplo 2.4GHz para la norma 802.11x. y así sucesivamente si nos vamos a una transmisión de varios canales de TV digital mas Internet, estamos hablando de 20 o 50GHz (comunicación satelital), pero sin entrar en esto podemos seguir con la idea.
Tercer gráfica es la señal dato montada en la portadora, como podemos ver al llamarse Amplitud Modulada, estamos diciendo que lo que se "Modula" es la amplitud de la señal portadora, como la amplitud de la función seno es el valor pico máximo que toma o bien valor pico a pico, este variara (se modulara) instantáneamente en función de la señal "Dato". entonces como vemos el tercer gráfico es función de la mezcla del primero y el segundo.
Imaginemos un oscilador de frecuencia fija al que le estamos variando la tensión de alimentación constantemente, la salida de este oscilador tendrá que variar también ya que es función de la tensión de alimentación, entonces de esta forma variamos la amplitud de salida quedando una amplitud modulada AM.

El circuito es muy simple, consta de tres etapas, oscilador (portadora), modulador (amplificador de audio) y mezclador (transistor de potencia).
El Oscilador se desarrollo en base a un oscilador a cristal de cuarzo con feedback en una compuerta (se puede usar cualquier compuerta, no precisamente tiene que ser una Schmitt Trigger.) la frecuencia esta dada por el valor del cristal, en mi caso utilice uno de 3,58MHz (extraído del oscilador de señal de crominancia de un TV color), pero es posible utilizar otro cristal de otro valor.
Este circuito genera una onda semi cuadrada, digo semi porque no llega a ser cuadrada pero nos servirá para el circuito, luego pasa por otras 2 compuertas para aprovechar las propiedades de la compuerta antirepique. 
El Amplificador es el encargado de tomar la señal de audio y amplificarla a un nivel tal que nos sea útil para mezclar con la portadora y comandar el transistor de potencia. Para ello utilice un TDA2003 pero es posible utilizar cualquier amplificador, ya sea integrado o a transistores.
El Mezclador es el transistor TIP122, utilice este darlington ya que tiene mayor ganancia que otros y me resume un poco el tema del mezclador, sino habría que polarizar una multietapa.
Este transistor es comandado por el oscilador el cual esta acoplado directamente a la base del mismo generando una frecuencia de 3,58MHz.
Si nosotros obviaríamos el amplificador de audio solo quedaría el choque de RF comandado por el transistor en configuración emisor común, de esta forma el choque recibiría los 3,59MHz y solo se emitirá por la antena la portadora. En un receptor de radio de esta frecuencia solo se ocuparía la estación pero no tendríamos dato alguno.
Para esto la tensión de alimentación de ese choque esta comandada por el amplificador de audio, entonces de esta forma se obliga a la señal de la portadora a modificar instantáneamente su amplitud en función de la señal de audio del amplificador, en otras palabras se modula en amplitud "AM", luego de comprender estos tres bloques solo resta acoplar la antena mediante un condensador de capacidad tal que su reactancia sea menor a la frecuencia de trabajo.
El Circuito:

Medidor de tensión con Leds



En base al conversor de tensión a diez niveles LM3914 (lineal), no queda bien decir que es un conversor análogo digital porque nos confundiríamos con los verdaderos ADC, pero en cierta forma convierte los distintos niveles de tensión en su entrada en forma digital representada con leds en su salida, que puede ser en modo punto o barra (conectando o no el pin 9).
El circuito presente es un voltímetro de continua el cual tiene un fondo de escala de 2V, pero con un divisor de tensión en su entrada es posible medir 2V, 20V, 200V, 2000V, etc.., claro que solo se mostrara en 10 leds por lo que la precisión es algo que no estaríamos buscando, este tipo de voltímetro puede servir por ejemplo para medir la carga de una batería, o bien junto a un conversor de frecuencia a tensión que fácilmente se puede desarrollar con un timer 555, podemos medir RPM, ya sea de un motor de automóvil o bien de un ventilador de una PC.
El circuito es el que propone el datasheet pero en este caso se han recalculado las resistencias de tensión de referencia para que sea posible llegar a un fondo de escala de 2V.

 

Programador de PIC serial JDM reducido ICSP


Este programador se desarrollo tomando como base el JDM original pero a diferencia del original se han eliminado algunos componentes que no eran necesarios, por ejemplo mi idea era utilizarlo directamente por ICSP, para ello he unificado la fuente ya que el JDM original se alimenta desde el puerto serial, es decir, alimenta el microcontrolador para poder ser grabado pero cuando nos encontramos con la programación en circuito tenemos el problema que el microcontrolador ya esta alimentado por la fuente de su circuito y también por la fuente del JDM, entonces al unificar la fuente ya no tenemos este problema, podemos programar el microcontrolador sin apagar la fuente.
El circuito solo tiene tres resistencias que son de limitación de corriente para el Clock, Data y Vpp, y un diodo zener de 13V 1/2W para la tensión del pin Vpp no pase los 13V.
Luego en el JDM original vemos dos transistores y otros diodos y resistencias, esto es porque aparte posee una fuente de 5,1V para alimentar el micro y también conmutar cuando hay señal, nosotros no lo utilizamos ya que la fuente es unificada.
Un software de grabación de microcontrolador por serie para JDM podría ser el ICprog, PonyProg, etc… el problema que he encontrado con estos es que no están actualizados para los últimos microcontroladores, tras una búsqueda en la red encontré el PICPgm que se encuentra disponible de forma gratuita tanto para Windows como para Linux, podemos encontrarlo en el siguiente link.




[Guia] LEDs


Light Emition Diode (LED) o Diodo Emisor de Luz, se trata de un semiconductor de la familia de los diodos, pero en este caso con la particularidad de emitir luz.


Como bien ya sabemos que hoy son muy utilizados en casi todo tipo de dispositivos, desde un simple Led opaco de luminosidad difusa y bajo brillo utilizado en monitor de estados, (un monitor de esta es un Led que indica en que estado esta un circuito por ejemplo el encendido de una PC, la cual lo indica un Led. O el flujo de datos en un disco rígido, etc.…). También se utilizan en matrices de Led por ejemplo marquesinas donde es posible mostrar texto o imágenes, También los podemos encontrar en linternas (estos leas ya son de mayor eficiencia), en backlight de monitores de LCD, TV, Celulares, etc.. También en medicina como lámparas de curado, en cultivos de plantas, en comunicaciones en forma de láser (Lugo detallaremos el tema), en señalización, etc.…
Como podemos ver son parte del día a día, y cada vez más, ya que ahora estamos empezando a verlos en luminarias en hogares y vecindarios.
Es notable que el consumo de un Led en relación a la luminosidad que nos proporciona es muy buena, por ello esta sobrepasando a las viejas lámparas fluorescentes.
Por el momento es una tecnología algo costosa en determinados países pero dentro de poco será muy accesible y las lámparas fluorescentes serán algo histórico (como esta pasando con las incandescentes).
El diodo Led esta formado por distintas aleaciones, como por ejemplo GaAs (Arsénico y Galio), GaAsAl (Arsénico, Galio y Aluminio), AsGaP (Arsénico, Galio y Fósforo),  GaN (Galio y Nitrógeno), ZnSe (Selenio y Zinc), InGaN (Indio, Galio y Nitrógeno), Si (Silicio), etc..
La composición también tiene que ver con el color ya que varía la energía con que se emiten los fotones.

GaAs    Infrarrojo                    940nm
AlGaAs  Rojo, Infrarrojo              890nm
GaAsP   Rojo, Anaranjado, Amarillo    630nm
GaP     Verde                         555nm
GaN     Verde                         525nm
ZnSe    Azul                         
430nm
InGaN   Azul                          450nm
SiC     Azul                          480nm
C       Ultravioleta                  380nm 


La luz se genera cuando el electrón pasa de un estado superior a uno inferior, es decir pierde energía que se manifiesta en forma de fotones, el color del Led es en función a la energía con que se desplaza el fotón, es decir varia su longitud de onda en función de la velocidad del fotón.
En función a esa velocidad y a grandes rasgos sin meternos en movimiento angular, fuerzas y partículas (física quántica) podemos decir que el color será función de la frecuencia, que es inversamente proporcional a la longitud de onda.
La longitud de onda el reciproco de la frecuencia, mientras mayor sea la frecuencia menor será la longitud de onda, y mientras menor sea la frecuencia mayor será la longitud de onda.
En el espectro de los colores podemos ver que a cada color le corresponde una longitud de onda medida en [nm] mientras menor sea la frecuencia mas nos acercamos al infrarrojo y mientras mayor sea la frecuencia mas nos acercamos al ultravioleta, en los puntos medios tenemos los colores.

 
La tensión de alimentación de un Led puede ir desde los 1,8V a los 3,8V esto para Leds estándar de alta luminosidad. Los de potencia se alimentan con 3,6V, 9V, 12V, etc… 

Rojo       = 1,8V a 2,2V
Anaranjado = 2,1
V a 2,2V
Amarillo   = 2,1
V a 2,4V
Verde      = 2
V   a 3,5V
Azul       = 3,5
V a 3,8V
Blanco     = 3,6V

Una formula básica para calcular la resistencia de un led:



Rled = (Vfuente - Vled) / Iled

Rled es la resistencia a calcular para el led
Vfuente es la tensión de la fuente que se utilizara para alimentar el led
Vled es la tensión del led
Iled es la intensidad o corriente del led.

Por ejemplo para el led Azul de 3,5V a 10mA alimentado con 12V
R = (12V – 3,5V) / 0,01A = 850ohms

La tensión de alimentación también depende del color, al igual que el consumo, existen muchos tipos de leds que poseen diferentes características, como tonalidad del color, corriente directa, potencia, tipo de lente, ángulo de apertura, flujo luminoso, densidad luminosa, etc..


El ángulo de apertura es en función de la lente que utiliza que a su vez nos dará como consiguiente la densidad luminosa que se mide en candelas [cd] mientras mas cerrado sea el ángulo de apertura de luz mayor serán las candelas del Led, ya que en un tamaño menor emitirá mayor luz, esto es la densidad.
Se puede ver en el grafico que mientras más agudo es el ángulo más denso será la luz, por ende mayor cantidad de candelas.


En cambio los leds de potencia al no poseer lente integrada (esto es porque nos da la posibilidad de usarlos tanto con lente o sin lente para una iluminación de una habitación por ejemplo), no se miden en candelas sino en lumen [lm], como una lámpara incandescente o fluorescente común.

 
Los leds actualmente están apareciendo cada vez en mas colores y mas formatos o encapsulados físicos, esto es porque se adecuan mas a las necesidades diarias, por ejemplo también tenemos la posibilidad de encontrar varios leds en un solo encapsulado, como los bicolor, tricolor y RGB, que comúnmente poseen un común que puede ser ánodo o cátodo y los pines de cada Led interno, que se pueden encender juntos o por separado, o bien variando su brillo independiente formar nuevos colores.
Por ejemplo los RGB se utilizan mucho para carteles de Led, o pantallas gigantes ya que al variarle la luminosidad a cada Led interno es posible crear distintos colores, y así poder realizar una imagen más realista. Normalmente se utilizan pulsos PWM para esta variación por su eficiencia y control.
También encontraremos leds automáticos, que parpadean solos al alimentarlos o bien que generan efectos y cambios de color (en el caso de los RGB).
Estos mismos leds de color o RGB también se encuentran en montajes superficiales de baja y alta potencia.

LED Orgánico (OLED) este tipo de leds es uno de los mas modernos hasta la fecha, el mismo es similar al convencional pero utiliza material orgánico para generar la luz, a partir de un polímetro orgánico tomado de células vivas se produce una electroluminiscencia al polarizar dicho material, el cual es de menor consumo y mayor brillo que los convencionales, hoy en DIA existen muchas tecnologías OLED pero se esta intentando dejar de lado la Orgánica para realizar una artificial a partir de la orgánica, para abaratar costos.

LED Estimulado (ELED) este tipo de Led es similar al DIODO LASER pero de menor coherencia, utilizado en punteros “láser” y otros dispositivos poco críticos en donde no se necesita una longitud de onda extremadamente estrecha.

LASER DIODE, como lo dice el nombre es un diodo de tecnología láser, el cual no funciona exactamente igual a un tubo láser convencional pero se acerca bastante, el mismo se utiliza en comunicaciones de fibra óptica, medicina, herramientas de corte, etc.…

PLC con PIC

uPLCCS son las siglas u [mu] "micro" - PLC "Controlador Lógico Programable" - CS [CCS] "Custom Computer Service". La idea de este PLC es que abre las posibilidades al lenguaje de programación, ya que no hay que limitarse a los lenguajes de objetos y lógicos de los conocidos PLC, sino que también se puede programar en C (de ahí CCS), en Basic, en Ensamblador, etc...
Esto nos proporciona una versatilidad aun mayor para lograr un programa óptimo y sencillo.
El circuito que se presenta es solo el modulo lógico de procesos, no tiene interfase de potencia como por ejemplo Relés, Triac, Transistores, etc...
El modulo cuenta con el conector paralelo para dicha expansión.
El mismo cuenta con 4 entradas digitales aisladas ópticamente 0 a 12V y 6 entradas analógicas las cuales tendrán que ser adaptadas según el sensor a conectar ya que el rango de medición para estas es de 0 a 5V.
El mismo posee la fuente integrada la cual se puede alimentar tanto en continua como alterna ya que cuenta con su puente de diodos que sirve aparte para no cometer errores en polaridad, es decir, se puede polarizar de cualquier forma.
Y algo importante es el método de programación, si bien es un micro de la firma Microchip, como sabemos se lo puede sacar del zócalo para montarlo en un programador o bien en este caso se integrado en la placa un conector ICSP (In-Circuit Serial Programming) esto nos permite con un solo cable de 5 hilos conectarlo al programador sin tener que sacar y poner el integrado con riesgos de romper algún pin.






En el siguiente video se puede ver como funciona este uPLCCS con el programa que se mostrara a continuación.
El programa lo que hace es testear tres botones los cuales el primero será una parada de emergencia que pondrá a ceros las salidas digitales, y el segundo y tercer botón son fines de carrera.
Lo que se simula con este programa es el movimiento de un motor que lleva y trae un carro de un punto a otro, cuando el carro llega a su limite se activa un fin de carrera invirtiendo dos salidas digitales (como se ve en el video los dos primeros leds son los que se invierten) de esta forma el motor cambia de sentido de giro y mueve el carro hacia el otro extremo donde se encuentra el otro fin de carrera que al activarse vuelve a invertir el sentido de giro del motor, esto se repite sucesivamente. A menos que se presione la parada de emergencia la cual pondrá a ceros la salida.

#include <16f883 .h=".h">
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOMCLR,INTRC
#use delay(int=4000000)
void main()
{
   output_c(0b11111111);
   delay_ms(800);
   output_c(0b00000000);
   delay_ms(800);
   while(TRUE){
      if (input(PIN_B0)==0)
         output_c(0b00000000);
      else
         if (input(PIN_B1)==0)
            output_c(0b01000000);
         else
            if (input(PIN_B2)==0)
               output_c(0b10000000);
   }            
}




Una forma muy buena de terminar este proyecto es programando este circuito o cualquier otro con un programa en LADDER, buscando por la web encontré un programa que es un compilador de LADDER para microconroladores Microchip (PIC) y Atmel (AVR), este programa es open source y pesa menos de 1MB, el mismo tiene muchísimas funciones para incluir en el programa y permite configurar el micro, por ejemplo su velocidad de clock, la asignación de pines (entradas, salidas, etc..).
Tambien funciona como simulador en tiempo real.
El programa se llama LDmicro, el mismo en su web tiene los binaros de descarga en multiples idiomas y tutoriales muy completos de como configurarlo y compilar.
Descarga la version en español aqui: http://cq.cx/dl/ldmicro-es.exe
Tutorial en ingles: http://cq.cx/ladder-tutorial.pl

Captura de pantalla del mismo programa anterior pero realizado en LADDER:







Preamplificador Valvular

Este circuito se realiza en base a la vieja y conocida válvula doble triodo 12AX7, la cual es muy utilizada en audio, ya sea instrumental u hogareño.
Como se trata de una válvula de baja potencia la usaremos como preamplificador, el circuito es muy básico ya que la idea era agregar esta etapa a un amplificador integrado de bajo ruido.
En el diagrama solo se observa un canal, pero dentro de la misma válvula se puede utilizar el otro canal sobrante copiando el circuito con los pines faltantes de la válvula.
Se eligió la configuración de 12V en su filamento porque en realidad es el transformador que tenia a mano., pero se pueden poner en paralelo y alimentar con 6,3V, ya verán en el diagrama que los dos filamentos están en serie con una toma central, eso nos permite configurarlo en 12V o en 6,3V.
 
Algunos datos técnicos de la válvula 12AX7:
 
Factor de Amplificación:  100 veces
Tensión del Ánodo:        250 V
Corriente del Ánodo:      1.2 mA
Tensión de Polarización:  -2 V
Impedancia del Ánodo:     62500 ohms
Tensión del filamento:    6.3 V






Switch


Es una estructura de control empleada dentro de las condiciones comunes como el famoso if. podría ser un reemplazo de los if anidados, por ejemplo si se requiere testear una variable la cual puede tomar múltiples valores, sera mas eficiente el uso del switch ya que emplear if anidados creara mayor cantidad de código.  
Se puede utilizar para testear una sola variable por ejemplo switch(variable) donde esta puede tomar valores numéricos los cuales seleccionaremos mediante case, por ejemplo si sabemos que dentro de variable podría venir el valor 64, o 128,  o 256, podemos utilizar case 64:, case 128: o case 256:, esto es para valores fijos. en nuestro ejemplo utilizamos intervalos abiertos, pero podrían ser abiertos, cerrados o ambos. esto nos sirve para tomar un delta.
notese que en la sintaxis se utiliza break; esto indica que ahí terminaran las operaciones dentro de la condición case.
A continuación se mostrara un ejemplo, el mismo encenderá los leds del puerto B gradualmente según el valor de entrada del adc.



#include <16F883.h>
#device adc=8
#FUSES NOWDT
#FUSES INTRC
#FUSES NOPUT
#FUSES NOMCLR
#FUSES NOPROTECT
#FUSES NOCPD
#FUSES NOBROWNOUT
#FUSES IESO
#FUSES FCMEN
#FUSES NOLVP
#FUSES NODEBUG
#FUSES NOWRT
#FUSES BORV40
#use delay(int=4000000)
void main()
{
   setup_adc_ports(sAN0|sAN1|VSS_VDD);
   setup_adc(ADC_CLOCK_DIV_2);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_ccp1(CCP_OFF);
   setup_comparator(NC_NC_NC_NC);
   int16 salida;
   while(true){
      set_adc_channel(0);
      delay_us(10);
      salida = read_adc();
      switch(true){
      case (salida >  0  && salida < 32):
         output_b(0b00000001);
         break;
      case (salida >  32 && salida < 64):
         output_b(0b00000011);
         break;
      case (salida >  64 && salida < 96):
         output_b(0b00000111);
         break;
      case (salida >  96 && salida < 128):
         output_b(0b00001111);
         break;
      case (salida > 128 && salida < 160):
         output_b(0b00011111);
         break;
      case (salida > 160 && salida < 192):
         output_b(0b00111111);
         break;
      case (salida > 192 && salida < 224):
         output_b(0b01111111);
         break;
      case (salida > 224 && salida < 256):
         output_b(0b11111111);
         break;        
      }  
   }
}
 

 

Control de Matriz Estática

Este programa sirve para demostrar el control de una matriz de 5x7 de forma estática, se crearon 8 letras en el estándar ASCII para matrices de 5x7, la palabra escrita es "ELECTGPL " se puede modificar por cualquier letra o bien agregarle mas o quitarle algunas.
El programa se realiza en dos etapas, la principal donde se realiza el multiplexado de las columnas y se muestran los valores de cada fila a una velocidad de 10ms y la interrupción por desbordamiento del timer, dentro de la interrupción se alojan los caracteres dentro de un switch el cual servirá para ir cambiando entre cada letra, ya que al final de cada caso tiene un contador "letra++" el cual será el valor a testear por el switch, a medida que se recorra cada una de las 5 columnas se incrementara en 1 la variable letra, de esta forma pasara al siguiente paso, por consiguiente la siguiente letra, la ultima letra en lugar de incrementar en 1, iguala a cero la variable letra, entonces comenzara de nuevo.
El tiempo esta dado por set_timer1(1000), es totalmente configurable a gusto del desarrollador.
Como el circuito utilizado es el más sencillo posible para que se encienda un Led debe existir un 1 y un 0 de cada lado de la matriz, se podría haber usado el selector de columnas como 0b11111110, 0b11111101, etc... Pero para comprenderlo fácil se utilizo un 1 donde se quiere encender, para que no salga la letra negada en la matriz se utilizo el operando "~" delante del vector de las filas, de esta forma complementa el valor de la variable para que se vea correctamente.
Para utilizar más columnas debería utilizarse mas salidas, como podemos imaginarnos, podríamos hacer una matriz de 8x8 con dos puertos del PIC, pero se puede hacer más grande implementando registros de desplazamiento serie/paralelo, como el 74164, 74595, 4094, etc... Estos integrados reciben los datos de las columnas de forma serial y lo despliegan en paralelo en sus salidas, los mismos se pueden concatenar para hacer matrices más grandes, estos integrados se controlan mediante un Clock de sincronismo, un Dato donde se enviaran los valores seriales, y un Reset que pondrá el puerto paralelo de los registros a ceros.




#include <16f883.h>
#fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOMCLR,INTRC
#use delay (int=4000000)
int fila[5],letra=0;
#INT_TIMER1
void isr()
{
   switch(letra){
      case 0: fila[0]=0b01000001;
              fila[1]=0b01000001;
              fila[2]=0b01001001;
              fila[3]=0b01001001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 1: fila[0]=0b00000001;
              fila[1]=0b00000001;
              fila[2]=0b00000001;
              fila[3]=0b00000001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 2: fila[0]=0b01000001;
              fila[1]=0b01000001;
              fila[2]=0b01001001;
              fila[3]=0b01001001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 3: fila[0]=0b01000001;
              fila[1]=0b01000001;
              fila[2]=0b01000001;
              fila[3]=0b01000001;
              fila[4]=0b00111110;
              letra++;
              break;
      case 4: fila[0]=0b01000000;
              fila[1]=0b01000000;
              fila[2]=0b01111111;
              fila[3]=0b01000000;
              fila[4]=0b01000000;
              letra++;
              break;
      case 5: fila[0]=0b00000110;
              fila[1]=0b01001001;
              fila[2]=0b01001001;
              fila[3]=0b01000001;
              fila[4]=0b00111110;
              letra++;
              break;
      case 6: fila[0]=0b00110000;
              fila[1]=0b01001000;
              fila[2]=0b01001000;
              fila[3]=0b01001000;
              fila[4]=0b01111111;
              letra++;
              break;
      case 7: fila[0]=0b00000001;
              fila[1]=0b00000001;
              fila[2]=0b00000001;
              fila[3]=0b00000001;
              fila[4]=0b01111111;
              letra++;
              break;
      case 8: fila[0]=0b00000000;
              fila[1]=0b00000000;
              fila[2]=0b00000000;
              fila[3]=0b00000000;
              fila[4]=0b00000000;
              letra = 0;
              break;
     }
     set_timer1(1000);

}
void main(void)
{
   enable_interrupts(INT_TIMER1);
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
   set_timer1(65535);
   enable_interrupts(GLOBAL);
   set_tris_c(0x00);
   set_tris_a(0x00);
   while(TRUE){
      output_a(0b00000001);
      output_c(~fila[0]);
      delay_ms(10);
      output_a(0b00000010);
      output_c(~fila[1]);
      delay_ms(10);
      output_a(0b00000100);
      output_c(~fila[2]);
      delay_ms(10);
      output_a(0b00001000);
      output_c(~fila[3]);
      delay_ms(10);
      output_a(0b00010000);
      output_c(~fila[4]);
      delay_ms(10);
   }
}


Adaptador de Matriz de 5 x 7 puntos.

Luego de comprar esta matriz y darme cuenta de que los pines no seguían un orden lógico... he desarrollado un adaptador para que los pines queden en orden, tal que con solo montarla en el protoboard sea posible aplicarla a los proyectos directamente.
Note se que los pines fueron soldados hacia abajo para poder montarla en el protoboard y así poder conectarla directamente, por ejemplo en el circuito que monte para testerla en esta nota, se puede ver que el ULN2003 que utilice como driver esta conectado directamente a los pines como se ve, no es necesario utilizar puentes extra.
Una mejora seria la de integrar el ULN y los 5 transistores directamente en el PCB. 
Estos componentes extra se consiguen en SMD por lo que sera sencillo y no necesitara mayores dimensiones en el PCB.
El firmware de esta nota no viene al caso pero igualmente lo subiré para completar la nota.



#include <16F883.h>
#use delay(int=4000000)
void main(){
int i;
byte const FILA[05] = {0b00000000,0b01101011,0b00101011,
                       0b01101001,0b00000000};
byte const COLU[05] = {0b00000001,0b00000010,0b00000100,
                       0b00001000,0b00010000};
   while(1){
     if(i>5){
       i=0;}
     else{
       OUTPUT_B(
FILA[i]);
       OUTPUT_C(COLU[i]);
       delay_ms(1);
       i++;}}}