Limitador de RPM con PIC16F628A

[elfrancho]

Hola amigos, soy nuevo en esto de los microcontroladores y por cierto me gusta mucho y le agarré muy bien la mano...  Mi idea es la siguiente.

Quiero hacer un limitador de RPM para un auto de 4 cilindros, que corte de 2400 RPM A 12000 RPM.

UN POCO DE TEORÍA
Un motor 4 cilindros a 2400 RPM tiene una frecuencia de pulsos en la bobina de 80Hz. Esto quiere decir que tendremos 80 pulsos en el intervalo de 1 segundo.

Bien, mi idea es la siguiente a ver si estoy encaminado.
Suponiendo que quiera cortar a 2400 RPM, y mi velocidad de sensado sea de 100milisegundos. La cantidad de pulsos contados en estos 100 ms van a ser 8.
Entonces quiero habilitar el Timer T0  para que me cuente pulsos que preovienen de la bobina, y cada 100 milisegundos fijarme si llegaron a 8. En caso de que sea así, Disparar un trasistor, poner en 0 el contador y volver a repetir la operacion.

Mis preguntas son las siguientes

Puedo yo cada 100ms fijarme en algun registro cuantas cuentas tengo en el Timer0 ?

Como puedo hacer para dejar correr esos 100 ms? puedo habilitar otro Timer que me llame a una interrupcion?

Agradecería se me ayudan un poco con el codigo assembler que como recien empiezo todabia me cuesta un poco..  si a alguien le intereza este proyecto este es mi MS.N: f.r.a.n.c.h.o@hotmail.com

[KALLITOS]

Hola francho, lo que yo haria es habilitar tanto la interrupcion por RB0 y timer 0, el timer lo programas para que active interrupcion cada 100ms y con el RB0 cuentas pulsos, te explico como funcionaria:

1) primer pulso de entrada
    1.1) colocas a 0 un registro que usaras como contador de pulsos.
    1.2) inicias timer0 con los 100 ms.
2) siguientes pulsos de entrada RB0
    2.1) aumentas el contador en 1
3) interrupcion timer0
    3.1) chekeas la catidad de pulsos recibidos y ejecutas lo que deseas.
    3.2) vas al punto 1

Y te aconsejaría empieces con un lenguaje facil y rapido de entender como el CCS o el PBP.

Saludos.

[elfrancho]

Gracias KALLITOS por tu MUY rápida respuesta, no alcancé a publicar mi duda que ya me la respondiste jajajaja..  Muy buena tu idea...  Ahora te hago algunas preguntitas...

1º La interrupción por RB0 se activa cada vez que RB0 cambia de estado?
1º Que metodo me recomendas para obtener 100ms +o- exactos en timer0???

En cuanto al lenguaje me metí de cabeza en assembler lo asimilé muy bien y me gusta..

Muchas gracias....

[KALLITOS]

Hola francho.

La RB0 tiene un bit de configuracion (que la encontrarás en el datasheet del pic que uses), el cual puedes escoger si es con el flanco de subida o de bajada del pulso, y la interrupcion se activará cada vez que se reciba el flanco seteado.

En este momento estoy en el trabajo para revisar, pero el maestro Redpic hizo un programa, diría yo, demasiado util para obtener valores de configuracion de timers tanto de 8 como de 16 bits, te recomendaría que lo descargues y lo uses no te arrepentiras.

Usando el soft mencionado, encontraras valores a usar, en caso no te den valores que desees, puedes configurar por ejemplo el timer0 a 50 ms y cada interrupcion aumentas un contador y chekas si se llega a 2 y tendras 100ms, adicionalmente visita la pagia de Redpic y Nocturno, encontraras ideas y codigo.

En el almacen del assembler encontras codigos y ejemplos.

Saludos

[elfrancho]

Hola francho.

La RB0 tiene un bit de configuracion (que la encontrarás en el datasheet del pic que uses), el cual puedes escoger si es con el flanco de subida o de bajada del pulso, y la interrupcion se activará cada vez que se reciba el flanco seteado.

En este momento estoy en el trabajo para revisar, pero el maestro Redpic hizo un programa, diría yo, demasiado util para obtener valores de configuracion de timers tanto de 8 como de 16 bits, te recomendaría que lo descargues y lo uses no te arrepentiras.

Usando el soft mencionado, encontraras valores a usar, en caso no te den valores que desees, puedes configurar por ejemplo el timer0 a 50 ms y cada interrupcion aumentas un contador y chekas si se llega a 2 y tendras 100ms, adicionalmente visita la pagia de Redpic y Nocturno, encontraras ideas y codigo.

En el almacen del assembler encontras codigos y ejemplos.

Saludos

Buenísimo, muy buena la data, estoy aprendiendo mucho, pero al final me decidí a hacerlo como al principio, ya que durante algunas interrupciones, voy a perder pulsos, cosa que contando con un Timer no... Me explico?  Aprovecharía un poco mas el Hardware y no tanto Software...   Solo que me llame una interrupcion cada 100 ms para ver si la cantidad de pulsos llegó a cirto valor...

Me interesa mucho eso del software de Redpic, me podrías dar la pagina? Como soy nuevo no conozco a nadie.. ...

Muchisimas gracias por tu ayuda y te voy a mantener al tanto de todo lo que vaya haciendo, aparte todo esto lo tengo en la cabeza todabía no hice nada..

Gracias y saludos...

[MLO__]

Hola.

La pagina del maestro entre maestros: PICMANIA by RedPic

[elfrancho]

Hola.

La pagina del maestro entre maestros: PICMANIA by RedPic

Muchas gracias MLO !!!!

[jeremylf]

Que yo sepa, cojer pulsos de la bobina para RPM requiere de un circuito algo grande para bajar voltajes y demas, tambien, los pulsos vienen con ruidos por demas, hayque saber como filtrarlos... Aunq quiza era solo en el auto que probe, bueno si encuentras solucion a esto, quisiera saberla xD

Suerte, haslo como te dicen, es mas exacto.. pero acuerdat de los ***** ruidos 

Salu2.

[elfrancho]

bueno genete, lo que hice ue lo siguiente....  Setiè T0 para q cada 100ms me llame a una interrupcion, Cuando atiendo la interrupcion, me fijo si los pulsos cnotados por Ra4 superan los pulsos setados, si es así, activo mi limitador...

Pero ahora tengo el siguiente problema, quizas pikman me puede ayudar acá, ya que el fabrica este tipo de cosas...


Problema, en 100ms w con un auto de 4 cilindros a 4800 RPM, puedo contar 16 pulsos de bobina,,,,  y me dan una resolucion de 300 RPM...  por ej: 
16 pulsos en 100ms = 4800 RPM
17 pulsos en 100ms = 5100 RPM

Y otro problea es que quiero tambien usarlo com controlador de largada...  y cortar cada 100ms es muy pausado para un controlador de largada, pero me encuentro con el problema de que si achico el tiempo de lectura, tengo cada vez menos resolución...

Que solucioón me darias amigo pikman??? 
Gracias y suerte....

[pikman]

Que solucioón me darias amigo pikman??? 

elfrancho, en principio te cuento que para nada soy de los que no les gusta brindar informacion, solamante que estoy demasiado ocupado hace un tiempo y no le estoy dedicando al foro el tiempo que se merece, asi que perdon por no responderte.

No tenes resolucion porque cuando tenes bajas revoluciones la cantidad de pulsos no la podes dividir, lo que tenes que hacer es medir el tiempo entre pulso y pulso, que sera el periodo, y a eso le haces la inversa y listo tenes la frecuencia por lo tanto las revoluciones, aca te pego un codigo que funciona, y lo podes adaptar al 16f628 porque tiene modulo CCP, que lo usa capturando los valores del timer1 entre un pulso y el otro, podes usar un XTAL de 4 MHZ y asi vas a tener incremento de 1 ms en el timer1 y es mas facil sacar las cuentas, de cualquier manera con 10 Mhz podes tener mas resolucion pero para lo que vos queres con 4 Mhz sobra, espero que te sirva, de hecho la rutina hace lo que vos queres.

saludos
ARIEL

Código: [Seleccionar]

//**********************************************************************
//
// Calcula la velocidad de rotacion contando el tiempo entre pulsos
//
//**********************************************************************

#include <16F877.h>

#fuses HS, NOWDT, NOLVP
#device *=16 ADC=10

#define COMENZAR  0
#define CONTANDO  1
#define TERMINO   2
#define VECES 2

#use delay (clock=10000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)



// Variables Globales

char cEstado;
int32 int32Cont;
float fRpm;

//************************************************************************
// RUTINAS DE INTERRUPCION

#int_ccp1
void CCP1__isr(void) {

    if (cEstado == CONTANDO) {       // Segundo Pulso
        int32Cont += CCP_1;           // Toma el valor de captura
        cEstado = TERMINO;           // Evito que vuelva a procesarse durante esta interrupcion
    }
    if (cEstado == COMENZAR)  {      // Primer Pulso
        set_timer1(0);               // Restaura el timer1 en este pulso
        cEstado = CONTANDO;
        int32Cont = 0;
    }
} // Fin CCP1__isr()


//************************************************************************
// CALCULO DE LA VELOCIDAD de rotacion

void velocidad(void){

    char cCnt;
    int32 int32Suma;
    long tiempo;

    cEstado = TERMINO;
    while (TRUE) {
      int32Suma = 0;
      int32Cont = 0;
      for (cCnt = 0; cCnt < VECES; cCnt++) {       // Acumula VECES lecturas
        cEstado = COMENZAR;                        // Permite comenzar a la interrupcion
        while (cEstado != TERMINO) {               // Espera hasta que se activa la interrupcion
          tiempo =  get_timer1();
          if (tiempo > 65500) {                    // Controla si el contador excedio el tiempo. Valor Original = 60000
            set_timer1(0);                         // Restaura el timer1 para seguir sumando el tiempo de este pulso
            int32Cont += tiempo;                   // Acumula para velocidades de viento bajas
          }                                        // Fin if
        }                                          // Fin if
        int32Suma += int32Cont;                    // Acumula los tiempos
      }                                            // fin for

      int32Suma /= VECES;                          // Saca el promedio de las VECES que se tomo la medicion
      fRpm = 1 / ( float ) int32Suma / 8 * 2.5;    // Periodo en uS
      fRpm *= 1000000;                             // Periodo en segundos
      printf("\rFRECUENCIA %05.1f Hz\r\r",fRpm);
      fRpm *= 60;                                 // Periodo en minutos
     printf("               %f     \r", fRpm);
    }

}// Fin velocidad()





//*****************************************************************
// MAIN
//
void main (void){

    setup_timer_1 (T1_INTERNAL | T1_DIV_BY_8 );
    setup_ccp1 (CCP_CAPTURE_FE);                    // Captura cada pulso = 0 (0v)

    delay_ms (200);

    enable_interrupts (INT_CCP1);
    enable_interrupts (GLOBAL);
    while(1){
      velocidad();
    }                                                //Fin While

} // Fin Main

//*****************************************************************************






[elfrancho]

Buenisimo Pikman Ariel......  Lo voy a mirar detenidamente y hacerlo en assembler... 

Y te hago una consulta...  me conviene hacerle una pequeña histeresis en la entrada por donde voy a contar los pulsos no???  de esta forma evito que cuente ruidos, rebotes....  La forma de hacerlo sería ver el menor tiempo entre pulsos (un motor 8 cilindros a altas revoluciones) y darle una histeresis un poco menor al tiempo calculado...

Estoy errado o creen que es buena idea???

[Algec]

Una pequeña cuestion, los limitadores de RPM de las motor por ejemplo lo que hacen es cortar dos cilindros, no los cuatro. Te lo comento para que lo tengas en cuenta.

[pikman]

Lo voy a mirar detenidamente y hacerlo en assembler... 

Assembler...., porque?, alguna razon o especificacion de quien te pide el trabajo?, creo que es una locura, fijate hay una variable float, no dudo que lo vayas a lograr pues se puede, salvo que quieras contar muchas revoluciones ( 50 mil o mas ), con una gran prescision, si queres no complicarte la vida y el motor tiene alternador, sacale un cable de una de las coneciones de la estrella o triangulo del alternador y listo, solo tenes que corregir la diferencia de la polea del cigueñal y la del alternador, si usas los pulsos del ditribuidor pone una inductancia en la entrada antes de que llegue a tu circuito y usa cable con malla, porque si hay perdidas en el sistema de alta tension fuiste.

Yo antes del llegar al micro puse un conformador de pulsos que lo hice con un operacional doble, para adaptar el nivel a TTL y filtrar el ruido.

saludos
ARIEL


 

[elfrancho]

Hola PIKMAN.....

Assembler...., porque?,

Hace 1 apenas 1 mes me inicié en el mundo de los PIC....  y después de tanto consultar para ver que lenguaje me recomendaban me decidí por Assembler, se que no es facil, en realidad C tampoco es facil, solo que algunas cosas se pueden simplificar pero bueno....  Ahora ya arranqué con assembler y la llevo bastante bien..

alguna razon o especificacion de quien te pide el trabajo?

Es para mi, yo ya tengo hecho un limitador, con un LM2917 convierto la frec en tensión y luego al comparo con una referencia....  Anda de lujo, y bueno, como decidí iniciarme en el mundo de los PIC me pareció una buena idea arrancar con este proyecto....

Cuando llegue a casa a la nochesita voy a subir un diagrama para que veas como pienso tomar los pulsos del negativo de la bobina...  no es nada del otro mundo pero creo que podria llegar a funcioinar bien y protege muy bien el puerto del micro...

En cuanto a lo del alternador es buena la idea... pero me parece mucho mas directa la relación de los pulsos de ignición...

Y bueno..  cuando empiece a hacer el programa voy a iur subiendo los avances si les parece para que los miren....  Hasta ahora tengo hecha la parte de inicio (configuracion de puertos, seteos de contadores, activacion de interrupciones)



Saludos y hasta esta noche....

[pikman]

Pues, mira, desde el ASM, podras controlar la 'maquina', pero los tiempos de desarrollo son mucho mas grandes, de hecho cuando yo comenze a trabajar con microcontroladores en 1985 ni siquiera habian compiladores, es decir, habia que del diagrama de flujo, pasar a nemotecnico, buscar el codigo hexadecimal que corespondiese y despues cargar posicion por posicion a mano en la memoria, para un sistema dosificador con una balanza, enfriado de tambores y paletizado, trabaje programando 4 meses, claro era lo primero que hacia, despues 8 años mas tarde fue cuando compre el primer kit de desarrollo donde ademas del compilador ASM gratis, estaban los manuales llenos de ejemplos y por su puesto el programador, y ahi abandone la linea motorola para quedarme con los PIC y a fines de 2002 empeze a programar en lenguaje C con el compilador de CCS y nunca mas, salvo me lo pidan especificamente hare algo en ASM, por eso era mi recomendacion.

El LM2917 es muy buen integrado yo lo use en un diseño para medir humedad relativa abiente, sube el esquematico  a ver de que se trata.

saludos
ARIEL