Me desenchufo…  nos vemos a la vuelta!

La forma más simple de variar la velocidad de un motor de corriente continua es variando la tensión de alimentación. El PWM es una señal de período fijo pero tiempo activo variable. Con esta señal se excita a los transistores del puente según el sentido de giro deseado.

Dadas las características constructivas del motor, este “no se da cuenta” de que alimentación es un tren de pulsos, sino que ve un valor de tensión continua igual al valor medio de dicho tren de pulsos. Con lo cual, variando el ancho de la porción activa de la señal de control se estará variando el valor medio y por consiguiente la velocidad del motor, simple no?

Circuito

En el circuito pueden verse 4 pulsadores, estos regulan velocidad ascendente, descendente, sentido de giro y arranca parada del motor. Sería conveniente una llave en lugar de un pulsador para el arranque/parada ya que esta debe estar apretada para que el motor gire.

Código Fuente

void main()
{
   set_tris_a(0xff);
   set_tris_b(0x00);
   output_low(PIN_B6);
   output_low(PIN_B7);
   do{
      if (!input(PIN_A0)){
         tiempo=tiempo+10;
         write_eeprom(0,tiempo);
      }
      if (!input(PIN_A1)){
         tiempo=tiempo-10;
         write_eeprom(0,tiempo);
      }
      if (!input(PIN_A3)){
         tiempo=read_eeprom(0);
         horario=read_eeprom(1);
         if (horario==0){
            output_low(PIN_B6);
            output_high(PIN_B7);
            delay_ms(tiempo);
            output_low(PIN_B7);
            delay_ms(256-tiempo);
         }else{
            output_low(PIN_B7);
            output_high(PIN_B6);
            delay_ms(tiempo);
            output_low(PIN_B6);
            delay_ms(256-tiempo);
         }
      }
      if (!input(PIN_A2)){
         horario=!horario;
         write_eeprom(1,horario);
      }
   }while (true);
}

Las variables tiempo y horario son del tipo byte y se definene en algún lugar libre de la memoria.
Simulación

Algunas aclaraciones

Si bien la simulación funciona bien, es necesario tener en cuenta que invertir el sentido de giro con el motor en marcha plena ocasiona corrientes muy alta por los transistores y puede llegar a destruirlos. Se puede modificar el código para que baje la velocidad y luego invierta la marcha.

El circuito es muy sencillo, sólo se necesita el teclado matricia, un display LCD y un conversor A/D. Para el ejemplo utilicé un PIC16F873A pero esta implementación es muy útil cuando disponemos de pocos terminales y, como dice el documento, es muy práctico para los PICs 12F de 8 terminales.

Simulación

Código Fuente

Utilizando la librería del CCS para LCDs el código es muy sencillo, consiste en comparar el valor de lectura del conversor A/D con el cálculo de tensión por cada tecla según el divisor resistivo que se utilice. Los límites de comparación de cada tecla mostrados son para los valores de resistencias del circuito y considerando una tolerancia del 1%.

#include <LCD.C>
void muestra(long valor);
void main()
{
   long tecla;
   set_tris_a(0xff);
   setup_adc(ADC_CLOCK_INTERNAL);
   setup_adc_ports(ALL_ANALOG);
   set_adc_channel(0);
   lcd_init();
   do{
      tecla=read_adc();
      muestra(tecla);
   }while(true);
}
void muestra (long valor){
   if ((valor >746)&(valor<761)){
      lcd_putc("1");
      delay_ms(400);
   }
      if ((valor >480)&(valor<490)){
      lcd_putc("2");
      delay_ms(400);
   }
   if ((valor >364)&(valor<372)){
      lcd_putc("3");
      delay_ms(400);
   }
   if ((valor >687)&(valor<701)){
      lcd_putc("4");
      delay_ms(400);
   }
   if ((valor >456)&(valor<465)){
      lcd_putc("5");
      delay_ms(400);
   }
   if ((valor >350)&(valor<357)){
      lcd_putc("6");
      delay_ms(400);
   }
   if ((valor >654)&(valor<668)){
      lcd_putc("7");
      delay_ms(400);
   }
   if ((valor >439)&(valor<448)){
      lcd_putc("8");
      delay_ms(400);
   }
   if ((valor >342)&(valor<349)){
      lcd_putc("9");
      delay_ms(400);
   }
   if ((valor >614)&(valor<626)){
      lcd_putc("\n");
      delay_ms(400);
   }
   if ((valor >330)&(valor<337)){
      lcd_init();
      delay_ms(400);
   }
   if ((valor >421)&(valor<430)){
      lcd_putc("0");
      delay_ms(400);
   }
}

El protocolo de comunicación entre el PIC y el DS18B20 se hace solamente utilizando un terminal del mismo, se llama 1-Wire interface y hay muchísimos dispositivos que lo utilizan, por lo que el código servirá para cualquiera de ellos.

Como se ve en la imagen de arriba, el DS18B20 viene en un encapsulado TO-92 y es muy sencillo de colocar en el elemento al cual queremos medirle la temperatura. En el circuito se puede ver que no puse ningún dispositivo calefactor, sino un led que enciende emulando que hay un circuito entregando calor en ese momento.

La ventana de histéresis térmica es de 1ºC, con lo cual mientras la temperatura medida esté dentro delñ rango [26..28]ºC el led estará apagado. Al momento de sobrepasar la temperatura de los 28ºC se activará una alarma (y quién desee puede agregar acá un circuito enfriador). Si la temperatura está por debajo de los 26ºC se activará el circuito calefactor hasta que llegue a la temperatura deseada.

Si bien este tipo de control es ON-OFF, dado la propia inercia térmica de la mayoría de los fluidos y elementos que se deben controlar la temperatura, podemos estar seguros que siempre estará en el entorno previsto.

En el código siguiente se puede ver que los valores máximos y mínimos de temperatura están en variables, por lo que es muy sencillo agregar unos pulsadores en los terminales libres para modificarlos mientras se está ejecutando el sistema. También recomiendo guardar estos valores en la EEPROM para evitar tener que hacer el set-point cada vez que se alimente el circuito.

void alarma();
void main(){
float temperatura;
float minimo;
float maximo;
lcd_init();
minimo=26;
maximo=28;
while (1){
temperatura = ds1820_read();
lcd_gotoxy(1,1);
printf(lcd_putc,"TEMP: %3.1f ", temperatura);
lcd_putc(223);
lcd_putc("C    ");
lcd_gotoxy(1,2);
if (temperatura<=minimo){
printf(lcd_putc,"Frio! Calentando");
 output_high(PIN_A1);}
if (temperatura>=maximo){
printf(lcd_putc,"Caliente!       ");
output_low(PIN_A1);
alarma();}
if ((temperaturaminimo)){
printf(lcd_putc,"Temperatura OK  ");
output_low(PIN_A1);}}
}
void alarma(){
output_high(PIN_B3);
delay_ms(100);
output_low(PIN_B3);
delay_ms(100);}

Las librerías usadas fueron las utilizadas acá y la propia del LCD que trae el CCS.

Simulacion en Proteus

En el video se puede apreciar los tres estados posibles del display el sonido de alarma cuando sube la temperatura. En el momento de grabar el video la simulación se hace bastante lenta (si, ya sé que tengo que cambiar la PC) es por eso que parece que la alarma suena un poco descoordinada.

A raíz del comentario de Justo en otro post, muestro aquí como manejar el sentido de giro de un motor de corriente continua. Básicamente la técnica consiste en hacer circular corriente continua en un sentido u otro según se quiera giro horario o antihorario. El diseño está basado en un microcontrolador PIC16F84A el cual corre un programa más que simple: Al presionar un pulsador el motor gira durante 3 segundos en un sentido y por otros 3 segundos en el sentido inverso.

El circuito que cumple las especificaciones es el siguiente:

El código fuente sería el listado aquí abajo, para el caso de querer modificar los tiempos en que gira en uno u otro sentido, sólo es necesario adecuar los tiempos en las líneas 10 y 13.

#use delay(clock=4000000)
#use fast_io(b)
#byte portb = 0x6
void main(){
set_tris_b(0x01);    //RB1 entrada, los demás salidas
portb = 0x00;
do{
if(input(PIN_B0)){
output_high(PIN_B1);
delay_ms(3000);
output_low(PIN_B1);
output_high(PIN_B2);
delay_ms(3000);
output_low(PIN_B2);
}
}while(true);
}

Simulación:

Aclaraciones importantes!

Conceptualmente el circuito de arriba cumple las especificaciones, pero hay que tener muy en cuenta que los microcontroladores están muy limitados en el manejo de corriente pos sus terminales. Es por esto que se hace necesario utilizar drivers de corriente para manejar la corriente que la carga requiera, en este caso el motor de cc. También utilizando drivers independizamos la tensión de alimentación que le entregamos al motor, ya que la mayoría de los motores de uso industrial están muy por encima de los 5v que utiliza el PIC.

Una posibilidad es utilizar un puente de transistores como el circuito que sigue, lo importante es tener en cuenta de nunca encender ambas ramas del puente al mismo tiempo, ya que esto ocasionaría un cortocircuito directo en la fuente de alimentación Vcc del motor. La elección de los transistores Q1..Q4 del puente dependerá de la corriente y la tensión Vce que deben soportar de acuerdo al motor que conectemos.

Más Aclaraciones!!

Con el código de arriba, es posible sólo la inversión de giro. Para el caso que además de esto se necesite controlar la velocidad de giro se puede implementar en el PIC una salida PWM. Prometo extender este tema en otros post y mostrar cómo podemos lograr una señal PWM utilizando PICs que traigan estos módulos o bien, escribirla por código para aquellos que no tienen incorporada esta funcionalidad como los PIC16F84AA.

Si bien el Proteus es una magnífica herramienta para realizar las simulaciones de los proyectos, no hay nada mejor para probar y debuggear que la placa física con el microcontrolador programado. Generalmente, suele ser un poco molesto realizar las plcasa de PCB para cada uno de los desarrollos o pruebas que uno quiera hacer con PICs. Atento a esto Microchip ofrece una cantidad de placas de desarrollo muy variada según el tema en el cual uno desarrollará la aplicación. En mi caso opté por la Explorer 16, se trata de una placa de desarrollo para PIC24 y dsPIC33 muy versatil y con muchas funcionalidades, las cuales describo a continuación con un ejemplo muy simple!

Descripción general

Haciendo click en la imágen se puede ver con mejor tamaño y (obviando el flash al sacar la foto), podemos destacar:

En la izquierda de la placa el conector RJ11 para el ICD2, el conector USB tipo B para utilizar las caractrísticas de comunicación USB del PIC18F4550 de montaje superficial que está ahí cerca, el conector DB9 para RS-232 y el conector para alimentar la placa.

En la parte inferior hay 4 pulsadores y arriba de estos 8 LEDs conectados mediante resistencias limitadoras a los terminales A0..A7 del PIC central. Este puede ser un PIC24 o dsPIC33. La Explorer 16 viene con un PIC24FJ128GA010 y un dsPIC33FFJ256GP710, ambos en un adaptador de SMD a conectores muy cómodos para la misma.

En la parte superior se puede observar el display de LCD de 16 caracteres y dos líneas, debajo de este un pulsador de reset y un potenciómetro para emular una entrada analógica. También hay un sensor de temperatura y un área para soldar componentes arriba a la derecha que no pienso usar nunca.

Por último a la izquierda puede verse el slot para conectar la Explorer 16 a otras placas de desarrollo de Microchip o bien a un circuito externo, aunque para esto último es preferible utilizar el conector negro vertical y dejar siempre disponible el puerto de expansión para futuras placas que adquiera.

Alimentando la placa por 1ra vez

Ni bien tuve la placa en mis manos le conecté la alimentación y probé los dos PICs que trae. Tal como me lo esperaba, ambos vienen programados con ejemplos donde se recorren casi todas las funcionalidades de la Explorer 16 y de cada uno de esos PICs. Por ejemplo, el ejemplo que viene en el PIC24F muestra en el LCD la temperatura, el valor que lee desde el potenciómetro, el día y la hora porque internamente ese PIC tiene un RTC y juego de luces con los LEDs. Uno va cambiando las funciones con los pulsadores.

Un ejemplo de uso

En otro post, recordé el auto fantástico y como generar un efecto como el de las luces de la trompa de aquel auto. Acádejo un video del mismo programa cargado al PIC24F (con algunas modificaciones menores). Quizás no se logre visualizar como muevo el potenciómetro pero si es evidente que el tiempo de encendido de cada LED va variando…

Recuerdan el auto fantástico? Bueno como se ve en la imagen, tenía una tira de LEDs que iban y venían de un lado a otro. Vamos a ver como podemos hacer esto con un PIC usando 8 LEDs y pudiendo cambiar el tiempo en que cada uno esté encendido. Para esto usaremos el compilador CCS y Proteus para la simulación.

Circuito

Bien simple, un PIC16F873A, una barra de 10 LEDs y un potenciómetro que permitirá regular el tiempo de encendido y dos resistencias: una fija un uno lógico en el pin MCLR y la otra limita la corriente por los LEDs.

Código
Con estas nuestro código aparecerá como el que

void main(){
long tiempo;
setup_adc_ports(AN0);
setup_adc(ADC_CLOCK_INTERNAL);
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);
set_tris_b(0x00);
set_tris_c(0x00);
portb = 0;
portc = 0;
set_adc_channel(0);
do{
output_high(PIN_B0);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B0);
output_high(PIN_B1);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B1);
output_high(PIN_B2);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B2);
output_high(PIN_B3);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B3);
output_high(PIN_B4);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B4);
output_high(PIN_B5);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B5);
output_high(PIN_B6);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B6);
output_high(PIN_B7);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B7);
output_high(PIN_C0);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_C0);
output_high(PIN_C1);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_C1);
output_high(PIN_C0);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_C0);
output_high(PIN_B7);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B7);
output_high(PIN_B6);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B6);
output_high(PIN_B5);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B5);
output_high(PIN_B4);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B4);
output_high(PIN_B3);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B3);
output_high(PIN_B2);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B2);
output_high(PIN_B1);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B1);
output_high(PIN_B0);
tiempo = read_adc();
delay_ms(tiempo);
output_low(PIN_B0);
}while(TRUE);}

Simulación

El resultado de la simulación se puede ver en este video, observar como varía el tiempo de encendido de cada LED a medida que se varía el potenciómetro:

]]> http://picadicto.wordpress.com/2009/08/05/leds-viajeros/feed/ 8 picadicto auto_fantastico circuito_auto_fantastico http://picadicto.wordpress.com/2009/08/04/%c2%a1manos-a-la-obra/ http://picadicto.wordpress.com/2009/08/04/%c2%a1manos-a-la-obra/#comments Wed, 05 Aug 2009 00:00:25 +0000 picadicto http://picadicto.wordpress.com/?p=11 ]]> Para empezar necesitaremos instalar algunas herramientas en la PC las cuales nos permitirán interactuar con los microcontroladores. La idea es armar un framework que nos permita escribir código, compilarlo y probarlo en un PIC.

Compilador

En primer lugar, se necesita un compilador. Básicamente es un programa donde se escribe el código (en algún lenguaje de programación) a ejecutar por el PIC y este se encarga de traducirlo al único lenguaje que los PICs entienden: código hexadecimal!

Tenemos varias opciones, a mi me gusta el MPLAB de Microchip para trabajar en assembler y el CCS para escribir el código C. Existen muchísimos compiladores algunos gratuitos, otros pagos, en versines educativas, crackeados, etc. y cada uno de ellos trabaja con distintos lenguajes. Pero, como antes, todos hacen los mismo: traducen el código para grabarlo al PIC.

Simulador

Luego de tener el código compilado es necesario probar si funciona. Para esto podemos ejecutar la propia simulación paso a paso de los compiladores o bien utilizar algo más moderno y mucho mejor: Proteus! El Proteus es un conjunto de herramientas diseñadas por la gente de Labcenter para electrónicos donde su principal virtud está en la capacidad de simular (no en tiempo real pero se asemeja bastante!) los microcontroladores PICs con el código compilado tal cual lo haría un PIC grabado en la realidad. Además el software proveé excelentes componentes para completar la simulación de nuestra aplicación como ser pulsadores, potenciómetros, LEDs, displays de todo tipo, memorias, USB, teclados y mucho más!

Programador

Hasta acá lo necesario para crear una aplicación y simular su funcionamiento. Si con esto no alcanza ya que queremos realmetne contruir la aplicación vamos a necesitar una interfaz de programación del microcontrolador. Es decir un aparato que sea capaz de grabar en la memoria del PIC real el código compilado.

En internet se pueden encontrar infinidades de circuitos caseros y comerciales para grabas a los microcontroladores PICs. Éstos pueden ser utilizando el puerto serie de la PC, vía USB o puerto paralelo. No me voy a detener mucho en esto ya que, como dije antes, hay mucha información en la web.

Microchip ofrece varios programadores yo utilizo el PICSTART PLUS y el ICD2. El primero es sólo programador y el ICD2 sirve además para debugg y programación in-circuit de los PICs.

El objetivo del blog no está muy claro todavía, pero lo que es seguro es que trataré de compartir al máximo las experiencias con los PICs y la forma con la que hago mis equipos y proyectos porque creo que el conocimiento es un derecho de todos y compartirlo hace bien!