Autor Tema: Serie Técnicas en C : Midiendo un pulso. 4ª Parte. El pulso completo. El Periodo  (Leído 16275 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5415
    • Picmania by Redraven
Midiendo un pulso. 4ª Parte. El pulso completo. El Periodo y la Frecuencia

A.- Conceptos involucrados:

Si lo creéis oportuno podéis antes darle un repaso a la misma sección de Conceptos de la parte 1ª de esta Técnica en C : Tiempo en Alto. Los coceptos son los mismos y aquí solo vamos a hacer algunas consideraciones sobre los mismos.

Decíamos allí que el Tiempo T que transcurre ente dos flancos sucesivos de subida (o de bajada) es lo que conocemos como Periodo del Pulso (Period), o sea: lo que dura un pulso completo.

Cada T segundos (ó milisegundos, ó microsegundos) tenemos un nuevo pulso completo.

Como vemos, cada pulso tiene un Tiempo en Alto (High Time) y un Tiempo en estado Bajo (Low Time). La suma de los dos es el Periodo T del pulso.



Como vemos en la imagen superior un pulso completo comienza con un flanco de subida en T1, sigue con uno de bajada en T2 y concluye en el nuevo flanco de subida T3.

Entre T1 y T2 permanece el pulso en Alto, Wh, mientras que entre T2 y T3 lo hace en bajo, Wl.

El tiempo transcurrido entre T1 y T3 es el Periodo del Pulso. Si este periodo lo expresamos en Segundos entonces su inverso, 1 / Periodo, es la Frecuencia del tren de pulsos.

Estos dos valores son los quie vamos a calcular con nuestro PIC: el Periodo T y la frecuencia F.

B.- Técnica a Aplicar:

Para medir el periodo T del pulso vamos a utilizar los dos mismos recursos que en la 1ª parte de este artículo, y de los que disponen la gran mayoria de los PIC's, tanto los de la serie 18F como los 16F:

El TIMER1 y la Interrupción Externa por RB0.

Para ver los detalles de estos recursos dadle también un vistazo a la primera parte de esta Técnica en C 1ª Parte. Tiempo en High.

(Quito este trozo para no sobrepasar los límites de un Post que nos impone el Foro  :P)


Aunque para calcular el Periodo del pulso y/o su Frecuencia no es necesario tomar el Tiempo T2 intermedio del Flanco de Bajada, ya que solo nos son necesarios T1 y T3, los dos flancos de Subida sucesivos, vamos a calcularlos todos ya que así tendremos también cuánto tiempo permanece tanto en alto como en bajo y tendremos de esta forma el tanto por ciento de la primera fase sobre la segunda del pulso, o sea: El Duty Cicle.

* Lo que vamos a realizar es:

1.- Configuraremos la Int_Ext por RB0 para detectar inicialmente el Flanco de Subida.
2.- Al llegarnos este Flanco de Subida guardaremos el valor en ese momento de TIMER1 y ...
3.- Cambiaremos la configuración de la Int_Ext por RB0 para detectar el siguiente Flanco de Bajada.
4.- Cuando nos llegue el Flanco de Bajada guardaremos de nuevo el valor de TIMER1 y ...
5.- Volveremos a configurar la Int_Ext por RB0 para detectar de nuevo un Flanco de Subida. Y ...
6.- Al llegarnos este nuevo Flanco de Subida guardaremos también el valor en ese momento de TIMER1 y ...
7.- Con estos tres valores de TIMER1 tendremos, expresados en Tick's de TIMER1, restando el tercero del primero, el tiempo que ha durado el Pulso. Multiplicando dicho número de Tick's de TIMER1 por el tiempo que dura cada Tick (dependiente del cristal que usemos) tendremos el Perido T que estamos buscando. Con 1 / T obtendríamos la frecuencia del Pulso.

C.- Implementación en C:

Para implementar nuestro Código en C vamos a centrarnos en los puntos que hemos descrito en la sección anterior.

Para configurar inicialmente el flanco de subida a detectar utilizaremos igual quen la primera parte:

Código: C
  1.    ext_int_edge(0,L_TO_H);                  // Configuro captura de 1er flanco de subida
  2.    flagToggleFlanco = 0;                    // inicializo el Flag para cambiar de flanco
  3.    enable_interrupts(int_ext);              // Habilito las interrupciones necesarias
  4.    enable_interrupts(global);
  5.  

Hemos añadido la variable int1 flagToggleFlanco debido a que una vez establecido el flanco a detectar no tenemos oportunidad de saber qué flanco es el que estamos esperando, así si flagToggleFlanco tiene un valor de 0 es que estamos esperando el de Subida y si por el contrario flagToggleFlanco tiene un valor de 1 entonces es el de bajada el que esperamos.

Con esta configuración inicial podemos ya escribir nuestra rutina ISR:

Código: C
  1. #int_ext
  2. void handle_ext_int(){
  3.  
  4.    ++numFlancoQueLlega;                     // Cuento flanco que nos llega
  5.    if(flagToggleFlanco==0){                 // He recibido Flanco de Subida
  6.       if(numFlancoQueLlega==1){
  7.          set_timer1(0);                     // Reinicio TMR1
  8.          t1=get_timer1();                   // Guardo en t1 el valor de TMR1 al primer Flanco de Subida
  9.       }
  10.       if(numFlancoQueLlega==3){
  11.          t3=get_timer1();                   // Guardo en t1 el valor de TMR1 al primer Flanco de Subida
  12.          if(flagHayDatos==0){               // Si los datos anteriores han sido procesados ...
  13.             flagHayDatos=1;                 // Indico que ya hay nuevos datos de flancos para calcular
  14.          }
  15.       }
  16.       ext_int_edge(0,H_TO_L);               // Configuro para capturar siguiente flanco de Bajada
  17.       flagToggleFlanco=1;                   // Indico que el siguiente flanco será de Bajada
  18.    } else {                                 // He recibido Flanco de Bajada
  19.       t2=get_timer1();                      // Guardo en t2 el valor de TMR1 al Flanco de Bajada
  20.       ext_int_edge(0,L_TO_H);               // Configuro para capturar siguiente flanco de subida
  21.       flagToggleFlanco=0;                   // Indico que el siguiente flanco será de Subida
  22.    }
  23.    FLASH;                                   // Reproduzco la entrada mediante un LEd en E0;
  24.    if(numFlancoQueLlega==3){
  25.       numFlancoQueLlega=0;
  26.    }
  27. }
  28.  

Fijaos que en la rutina ISR anterior no realizamos ningún cálculo. Aplicamos aqui el principio fundamental de que "dentro de una rutina de interrupción haz lo debas y abandónala lo antes que puedas". Asi que si tenemos valores válidos de T1, T2 y T3 entonces solo hacemos que flagHayDatos valga 1 y ya trataremos estos valores dentro de main().

Con numFlancoQueLlega sabremos qué flanco de Subida es T1 y cúal es T3 ya que solo cuando obtengamos T3 daremos por concluida nuestra captura.

Código: C
  1.       if(flagHayDatos==1){                  // Detecto que ya hay datos de flancos ...
  2.          if((t3>t2)&&(t2>t1)){              // Compruebo que estoy en la misma vuelta de TMR1
  3.             tth = t2 - t1;                  // Calculo en Tick's de TMR1 el tiempo en Alto
  4.             ttl = t3 - t2;                  // Calculo en Tick's de TMR1 el tiempo en Bajo
  5.             tt  = tth + ttl;                // Calculo en Tick's de TMR1 el Periodo del Pulso
  6.             sth = uSxTick * tth;            // Calculo en uS el tiempo en Alto.
  7.             stl = uSxTick * ttl;            // Calculo en uS el tiempo en Bajo.
  8.             st  = uSxTick * tt;             // Calculo en uS el tiempo el Periodo.
  9.             f   = 1 / (st / 1000000);       // Calculo la Frecuencia
  10.             flagHayTransmitir=1;            // Indico que tengo nuevo valor para transmitir
  11.          }
  12.          flagHayDatos=0;                    // Indico que ya han sido procesados los datos.
  13.       }
  14.  


Cuando flagHayDatos es 1 podemos proceder a calcular los Ticks transcurridos entre un flanco y otro.

Fijaos que preguntamos si T3 es mayor que T2 y que éste es a su vez mayor que T1. Esto es debido a una limitación que nos impone el no tener en cuenta vueltas completas de TIMER1 para realizar nuestros cálculos: T3, T2 y T1 deben estar dentro de una misma vuelta de TIMER2, o sea que el pulso debe ser menor que 13,1072 milisegundos. Notad que cuando detectamos el primer  flanco volvemos a poner TIMER1 a cero para recomenzar siempre cerca del inicio de la cuenta de TIMER1 y evitar asi su desborde.

Para computar tiempos de pulso mayores 13,1072 milisegundos solo habría que computar tambien cuantas veces se desborada completo TIMER1 y realizar los cálculos aritméticos correspondientes.

Al igual que hacíamos en la Rutina ISR en que no calculábamos sino que solo indicábamos que podíamos calcular, aquí una vez realizados los calculos de Tick´s y su equivalencia en segundos no los transmitimos, sólo indicamos que hay datos para transmitir mediante poner a 1 flagHayTransmitir.

Para transmitir el último valor computado vamos a implementar una recepción vía serie RS232 que al recibir el comando 'T' nos envía el último valor correcto registrado:

Código: C
  1.       if(Command!=0x00){                    // Si he recibido un comando vía Serie ...
  2.          if(Command=='T'){                  // Si el comando es 'T' (Transmite) ...
  3.             if(flagHayTransmitir==1){       // Si hay algo pendiente de transmitir ...
  4.                printf("Ticks ....... H  %4Lu + L  %4Lu =  %4Lu\r\n",tth,ttl,tt);
  5.                printf("uSegundos ... H %3.1f + L %3.1f = %3.1f F = %4.2f Hz\r\n\n",sth,stl,st,f);
  6.                flagHayTransmitir=0;         // Indico que ya he transmitido lo pendiente.
  7.             }
  8.          }
  9.          Command=0x00;                      // Indico que ya he procesado el comando.
  10.       }
  11.  

Con todo esto el programa completo para nuestro Detector de Periodo y Frecuencia de un Pulso queda así:

Código: C
  1. ////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Midiendo_un_pulso_2_Complete.c
  4. //
  5. // SERIE: "Técnicas en C" para el Foro TODOPIC
  6. //
  7. // (c) 10.2006 by RedPic
  8. //
  9. // Propósito: Medir los tiempos en alto y bajo que permanece un pulso : Periodo y Frecuencia
  10. //
  11. // Condiciones de Test: Inyección por RB0 de una señal de 2 Khz (0.5 ms de periodo)
  12. //
  13. // Técnica Empleada: Detectar mediante la Interrupción Externa por RB0
  14. //                   un flanco de subida de un pulso, guardar el estado
  15. //                   de TMR1,  detectar  a  continuación el  siguiente
  16. //                   flanco de bajada, guardar el nuevo estado de TMR1,
  17. //                   detectar a continuación un nuevo flanco de subida,
  18. //                   guardar nuevamente el estado de TMR1 y realizar la
  19. //                   correspondiente substracción de ellos para obtener
  20. //                   el tiempo que permanece en alto y bajo y transmitir
  21. //                   los resultados mediante el puerto RS232 a petición.
  22. //
  23. ////////////////////////////////////////////////////////////////////////////////////
  24.  
  25.  
  26. #include <18f4550.h>
  27. #fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN
  28. #use delay(clock=20000000)
  29.  
  30. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)
  31.  
  32.  
  33. ////////////////////////////////////////////////////////////////////////////////////
  34. //
  35. // Defines y Constantes
  36. //
  37. ////////////////////////////////////////////////////////////////////////////////////
  38.  
  39. #define LED PIN_E0                          // Defino el Pin del Led
  40. #define FLASH Output_Toggle(LED)            // Defino la funcion Flash de monitor
  41.  
  42. float const uSxTick = 0.2;                  // Microsegundos por Tick de TMR1 a 20 Mhz
  43.  
  44.  
  45. ////////////////////////////////////////////////////////////////////////////////////
  46. //
  47. // Variables en RAM
  48. //
  49. ////////////////////////////////////////////////////////////////////////////////////
  50.  
  51. char  cRec=0x00;                            // Último caracter recibido via serie
  52. char  Command=0x00;                         // Comando a procesar
  53. int8  numFlancoQueLlega=0;                  // Número de Flanco que llega
  54. int1  flagToggleFlanco=0;                   // Flag para cambiar de flanco
  55. int16 t1=0x00,t2=0x00,t3=0x00;              // Variables para guardar estados de ...
  56. int16 tth=0x00,ttl=0x00,tt=0x00;            // Timers y pulsos.
  57. float sth=0.0,stl=0.0,st=0.0,f=0.00;        // Para hacer las restas oportunas en uS
  58. int1  flagHayDatos=0;                       // Flag para indicar que ya hay datos de ..
  59.                                             // dos flancos (de subida y bajada)
  60. int1  flagHayTransmitir=0;                  // Flag para indicar que hay datos para ...
  61.                                             // Transmitir al PC.
  62.  
  63. ////////////////////////////////////////////////////////////////////////////////////
  64. //
  65. // Interrupción por Recepción Serie RS232
  66. //
  67. ////////////////////////////////////////////////////////////////////////////////////
  68.  
  69.  
  70. #int_rda
  71. void handle_rda_int(){
  72.  
  73.    if(kbhit()){                             // Si hay algo pdte de recibir ...
  74.       cRec=getc();                          // lo recibo sobre cRec ...
  75.       if(cRec!=0x00){                       // Si es distinto de \0 ...
  76.          Command=ToUpper(cRec);             // cargo cRec sobre Command para procesarlo
  77.       }                                     // pasándolo a Mayúsculas para no confundir.
  78.    }
  79. }
  80.  
  81. ////////////////////////////////////////////////////////////////////////////////////
  82. //
  83. // Interrupción por Externa por Cambio de Flanco en RB0
  84. //
  85. ////////////////////////////////////////////////////////////////////////////////////
  86.  
  87.  
  88. #int_ext
  89. void handle_ext_int(){
  90.  
  91.    ++numFlancoQueLlega;                     // Cuento flanco que nos llega
  92.  
  93.    if(flagToggleFlanco==0){                 // He recibido Flanco de Subida
  94.  
  95.       if(numFlancoQueLlega==1){
  96.          set_timer1(0);                     // Reinicio TMR1
  97.          t1=get_timer1();                   // Guardo en t1 el valor de TMR1 al primer Flanco de Subida
  98.       }
  99.       if(numFlancoQueLlega==3){
  100.          t3=get_timer1();                   // Guardo en t1 el valor de TMR1 al primer Flanco de Subida
  101.          if(flagHayDatos==0){               // Si los datos anteriores han sido procesados ...
  102.             flagHayDatos=1;                 // Indico que ya hay nuevos datos de flancos para calcular
  103.          }
  104.       }
  105.       ext_int_edge(0,H_TO_L);               // Configuro para capturar siguiente flanco de Bajada
  106.       flagToggleFlanco=1;                   // Indico que el siguiente flanco será de Bajada
  107.  
  108.    } else {                                 // He recibido Flanco de Bajada
  109.  
  110.       t2=get_timer1();                      // Guardo en t2 el valor de TMR1 al Flanco de Bajada
  111.       ext_int_edge(0,L_TO_H);               // Configuro para capturar siguiente flanco de subida
  112.       flagToggleFlanco=0;                   // Indico que el siguiente flanco será de Subida
  113.    }
  114.  
  115.    FLASH;                                   // Reproduzco la entrada mediante un LEd en E0;
  116.  
  117.    if(numFlancoQueLlega==3){
  118.       numFlancoQueLlega=0;
  119.    }
  120.  
  121. }
  122. void main() {
  123.  
  124.  
  125.     ////////////////////////////////////////// INICIALIZACIONES GENERALES
  126.  
  127.    delay_ms(333);                           // Espero a que todo se estabilice e ...
  128.    disable_interrupts(global);              // Inicializo el Micro y ...
  129.    disable_interrupts(int_timer1);          // deshabilitando todo lo no necesario ...
  130.    disable_interrupts(int_rda);
  131.    disable_interrupts(int_ext);
  132.    disable_interrupts(int_ext1);
  133.    disable_interrupts(int_ext2);
  134.    setup_adc_ports(NO_ANALOGS);
  135.    setup_adc(ADC_OFF);
  136.    setup_spi(FALSE);
  137.    setup_psp(PSP_DISABLED);
  138.    setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
  139.    setup_timer_0(RTCC_OFF);
  140.    setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
  141.    setup_timer_2(T2_DISABLED,0,1);
  142.    setup_timer_3(T3_DISABLED);
  143.    setup_comparator(NC_NC_NC_NC);
  144.    setup_vref(FALSE);
  145.    port_b_pullups(FALSE);
  146.    delay_ms(333);
  147.  
  148.    /////////////////////////////////////////// INICIALIZACIONES PERTINENTES A LA APLICACION
  149.  
  150.    set_tris_c(0b10000000);                  // Habilito como entrada RC7 para canal RS232
  151.  
  152.    ext_int_edge(0,L_TO_H);                  // Configuro captura de 1er flanco de subida
  153.    flagToggleFlanco = 0;                    // inicializo el Flag para cambiar de flanco
  154.  
  155.    enable_interrupts(int_rda);              // Habilito las interrupciones necesarias
  156.    enable_interrupts(int_ext);
  157.    enable_interrupts(global);
  158.  
  159.    printf("\r\nMidiendo un pulso : Periodo\r\n");
  160.    printf("By Redpic para Foro TODOPIC\r\n\n");
  161.  
  162.    do {
  163.  
  164.       if(flagHayDatos==1){                  // Detecto que ya hay datos de flancos ...
  165.          if((t3>t2)&&(t2>t1)){              // Compruebo que estoy en la misma vuelta de TMR1
  166.             tth = t2 - t1;                  // Calculo en Tick's de TMR1 el tiempo en Alto
  167.             ttl = t3 - t2;                  // Calculo en Tick's de TMR1 el tiempo en Bajo
  168.             tt  = tth + ttl;                // Calculo en Tick's de TMR1 el Periodo del Pulso
  169.             sth = uSxTick * tth;            // Calculo en uS el tiempo.
  170.             stl = uSxTick * ttl;            // Calculo en uS el tiempo.
  171.             st  = uSxTick * tt;             // Calculo en uS el tiempo.
  172.             f   = 1 / (st / 1000000);       // Calculo la Frecuencia
  173.            
  174.             flagHayTransmitir=1;            // Indico que tengo nuevo valor para transmitir
  175.          }
  176.          flagHayDatos=0;                    // Indico que ya han sido procesados los datos.
  177.       }
  178.       if(Command!=0x00){                    // Si he recibido un comando vía Serie ...
  179.          if(Command=='T'){                  // Si el comando es 'T' (Transmite) ...
  180.             if(flagHayTransmitir==1){       // Si hay algo pendiente de transmitir ...
  181.  
  182.                printf("Ticks ....... H  %4Lu + L  %4Lu =  %4Lu\r\n",tth,ttl,tt);
  183.                printf("uSegundos ... H %3.1f + L %3.1f = %3.1f F = %4.2f Hz\r\n\n",sth,stl,st,f);
  184.  
  185.                flagHayTransmitir=0;         // Indico que ya he transmitido lo pendiente.
  186.             }
  187.          }
  188.          Command=0x00;                      // Indico que ya he procesado el comando.
  189.       }
  190.  
  191.  
  192.    } while (TRUE);
  193. }
  194.  

D.- Ejemplo funcionando:



Y esto es todo por hoy, amigos.  :mrgreen:
Mañana, más.

« Última modificación: 24 de Octubre de 2014, 09:48:59 por RedPic »
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado Azicuetano

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1020
    • Aplicaciones Electrónicas en Alicante.
Muy buen artículo Diego.

La de horas que vas a ahorrar a la gente que lea esto!!! jeje



Un saludo desde Alicante

Desconectado Nocturno

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 17502
    • MicroPIC
(Quito este trozo para no sobrepasar los límites de un Post que nos impone el Foro  :P)
Jajaja, ¡se te ha quedado pequeño el foro, Diego!

Enhorabuena por esta nueva serie divulgativa que acabas de comenzar.
Un saludo desde Sevilla, España.
Visita MicroPIC                                                                                        ɔ!doɹɔ!ɯ ɐʇ!s!ʌ

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5415
    • Picmania by Redraven
Jua, jua, jua  :D  :D  :D

Después no me creéis cuando hablo de "mis novelas" ...  :mrgreen:

Y es que me pongo, me pongo ... y no se cuando parar ... ja ja ja  :D  :D  :D

Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado M.C_Barquin

  • PIC12
  • **
  • Mensajes: 69
Como siempre enhorabuena D.Diego.Magnífico artículo con el que todos aprendemos un poquito más.Saludos.
Pensando en Verdiblanco

Desconectado pikman

  • Moderador Local
  • PIC24F
  • *****
  • Mensajes: 674
Estimado RED, tengo que decirte que te admiro por tu capacidad de enseñar..., vaya eres todo un profesor, pues es muy interesante lo que has planteado, excelente tu trabajo, graficos, bueno para sacarse el sombrero, te queria comentar que yo hice algo parecido pero usanso el CCP, que tambien genera una interrupcion en cada cambio y captura el registro del TMR1, no se si es exactamente lo mismo aca va el codigo entonces, bueno Red, gracias por tu aporte al foro, saludos

//**********************************************************************
// viento2.c
//
// Calcula la velocidad de rotacion contando los pulsos recividos
//
//**********************************************************************

#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)

#use standard_io (A)
#use standard_io (B)


// 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
//        printf("          int32Cont %lu     CCP1: %lu\r",int32Cont,CCP_1);
    }
    if (cEstado == COMENZAR)  {      // Primer Pulso
        set_timer1(0);               // Restaura el timer1 en este pulso
        cEstado = CONTANDO;
        int32Cont = 0;
  //      printf("\r  Timer1 a CERO\r");
    //    printf("I int32Cont: %lu\r",int32Cont);
    }
} // Fin CCP1__isr()


//************************************************************************
// CALCULO DE LA VELOCIDAD DEL VIENTO
//
void velocidad_viento(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
//printf("B int32Cont: %lu\r",int32Cont);
          }                                        // Fin if
        }                                          // Fin if
        int32Suma += int32Cont;                    // Acumula los tiempos
      }                                            // fin for

//      printf("int32Suma %lu    \r",int32Suma);
      int32Suma /= VECES;                          // Saca el promedio de las VECES que se tomo la medicion
//      printf("int32Suma %lu    \r",int32Suma);
      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_viento()





//*****************************************************************
// 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_viento();
    }                                                //Fin While

} // Fin Main

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

saludos
PikMan

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1338
Hola RedPic.

La causa de mi mensaje esque leyendo los grandes articulos q haces, que de paso dejame decirte q son muy benos, exactamente el "Midiendo un pulso - 4ª Parte - El pulso completo - El Periodo y la Frecuencia" me tope con un problema.

Entiendo como haces todo, aunq aveces tengo dificultad por entender esto de los TIMER0, 1,... mas que nada en la configuracion de estos. Bien, el problema q tengo esq yo uso el PIC18F2550 y para compativilizarlo con esa Tecnica en C q utilizas para medir un pulso completo solo cambie el #include y quite en el main esto: setup_psp(PSP_DISABLED) porque el F2550 no lo reconoce.

Lo q sucede esq funciona y todo pero cuando genero unos pulsos (porq tengo un generador, pero ahi no hay problema) grandes, el pic por rs232 muestra otro valor diferent a este (no es igual al q muestra el osciloscopio) y ensi lo q quisiera saber es: ¿La configuracion q haces al empezar el main (las desabilitaciones y eso) esta bien si pongo el 18F2550? y sino puedes porfavor decirme como esq quedaria para este pic? Ojala no sea en los fusibles tampoco.

Disculpa mi ignorancia.


Gracias, salu2


PD: No quise pretendr ser egoista, losiento  :P

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1338
Antes que nada disculpen el doble post.

Lo q sucede esq viendolo y viendolo me di cuenta q mostraba esos valores por rs232 disitintos al del osciloscopio porq el pulso era muy grande y el Timer1 llegaba a su desbordamiento (13,...). Bien, entonces cambie: setup_timer_1(T1_INTERNAL | T1_DIV_BY_1) por:  setup_timer_1(T1_INTERNAL | T1_DIV_BY_2) (ó 4, 6, 8) pero me lee valores diferentes porq creo q demora mas o nose q es lo q pasara.

Entonces, tu dijiste q no meterias nada de un conteo por desbordamiento del timer1 pero parece q es lo necesito, amenos q tengas otra forma para hacerlo, por ahora es la unica forma q veo poder hacerlo, contar las veces q se desbordo. Lo q quisiera, y porfavor, esq me ilustraras como seria este conteo por desbordamiento yaq con los Timer's no me meto mucho por ahora porq no los entiendo bien y nose como hacer un conteo de este. Espero no sea mucho pedir un ejemplo pero es lo q quiero, disculpa.

Gracias por tu tiempo.


salu2 8) 8) 8)

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5415
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 4ª Parte. El pulso completo. El Per
« Respuesta #8 en: 21 de Agosto de 2007, 03:06:41 »
Ahora estoy en el trabajo, cuando llegue a casa te contesto a todo, peor para empezar muéstranos tu código y trabajamos sobre él.
 
« Última modificación: 21 de Agosto de 2007, 03:12:25 por RedPic »
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1338
Bien gracias.

Lo q llevo avanzado en mi codigo no es mas q el cambio del #include y una directiva en el main q es solo para el 18F450.

Bueno igual aqui lo pongo:
Código: [Seleccionar]
#include <18f2550.h>
#fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN
#use delay(clock=20000000)

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


////////////////////////////////////////////////////////////////////////////////////
// Defines y Constantes
////////////////////////////////////////////////////////////////////////////////////
#define LED PIN_B5               //E0 Defino el Pin del Led
#define FLASH Output_Toggle(LED) // Defino la funcion Flash de monitor

float const uSxTick = 0.2;       // Microsegundos por Tick de TMR1 a 20 Mhz


////////////////////////////////////////////////////////////////////////////////////
// Variables en RAM//
////////////////////////////////////////////////////////////////////////////////////
char cRec = 0x00;                      // Último carácter recibido vía serie
char Command = 0x00;                   // Comando a procesar
int8 numFlancoQueLlega = 0;            // Número de Flanco que llega
int1 flagToggleFlanco = 0;             // Flag para cambiar de flanco
int16 t1 = 0x00, t2 = 0x00, t3 = 0x00;       // Variables para guardar estados de ...
int16 tth = 0x00, ttl = 0x00, tt = 0x00;     // Timers y pulsos.
float sth = 0.0, stl = 0.0, st = 0.0, f = 0.00; // Para hacer las restas oportunas en uS
int1 flagHayDatos = 0;                 // Flag para indicar que ya hay datos de ..
                                     // dos flancos (de subida y bajada)
int1 flagHayTransmitir = 0;            // Flag para indicar que hay datos para ...
                                     // Transmitir al PC.


////////////////////////////////////////////////////////////////////////////////////
// Interrupción por Recepción Serie RS232
////////////////////////////////////////////////////////////////////////////////////
#int_rda
void handle_rda_int()
{
  if (kbhit())    // Si hay algo pdte de recibir ...
  {             
    cRec = getc();             // lo recibo sobre cRec ...
    if (cRec != 0x00)       // Si es distinto de \0 ...
    {
      Command = ToUpper(cRec); // cargo cRec sobre Command para procesarlo
    }                        // pasándolo a Mayúsculas para no confundir.
  }
}

////////////////////////////////////////////////////////////////////////////////////
// Interrupción por Externa por Cambio de Flanco en RB0
////////////////////////////////////////////////////////////////////////////////////
#int_ext
void handle_ext_int()
{
  ++numFlancoQueLlega;     // Cuento flanco que nos llega
 
  if (flagToggleFlanco == 0)  // He recibido Flanco de Subida
  {
    if (numFlancoQueLlega == 1)
    {
      set_timer1(0);       // Reinicio TMR1
      t1=get_timer1();     // Guardo en t1 el valor de TMR1 al primer Flanco de Subida
    }
    if(numFlancoQueLlega == 3)
    {
      t3 = get_timer1();     // Guardo en t1 el valor de TMR1 al primer Flanco de Subida     
      if (flagHayDatos == 0)  // Si los datos anteriores han sido procesados ...
      {
        flagHayDatos = 1;    // Indico que ya hay nuevos datos de flancos para calcular
      }
    }
    ext_int_edge(0, H_TO_L); // Configuro para capturar siguiente flanco de Bajada
    flagToggleFlanco = 1;     // Indico que el siguiente flanco será de Bajada
  }
  else                     // He recibido Flanco de Bajada
  {                 
    t2=get_timer1();        // Guardo en t2 el valor de TMR1 al Flanco de Bajada
    ext_int_edge(0, L_TO_H); // Configuro para capturar siguiente flanco de subida
    flagToggleFlanco = 0;     // Indico que el siguiente flanco será de Subida
  }
 
  FLASH;                    // Reproduzco la entrada mediante un LEd en E0;
 
  if (numFlancoQueLlega == 3) //Reinicio el Flag q llega para poder leer otro pulso.
  {
    numFlancoQueLlega=0;
  }
}

////////////////////////////////////////////////////////////////////////////////////
// Inicio Programa.
////////////////////////////////////////////////////////////////////////////////////
void main()
{
  //INICIALIZACIONES GENERALES//
  delay_ms(333); // Espero a que todo se estabilice e ...
  disable_interrupts(global); // Inicializo el Micro y ...
  disable_interrupts(int_timer1); // deshabilitando todo lo no necesario ...
  disable_interrupts(int_rda);
  disable_interrupts(int_ext);
  disable_interrupts(int_ext1);
  disable_interrupts(int_ext2);
  setup_adc_ports(NO_ANALOGS);
  setup_adc(ADC_OFF);
  setup_spi(FALSE);
  //setup_psp(PSP_DISABLED);  //Para 18F4550.
  setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
  setup_timer_0(RTCC_OFF);
  setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
  setup_timer_2(T2_DISABLED,0,1);
  setup_timer_3(T3_DISABLED);
  setup_comparator(NC_NC_NC_NC);
  setup_vref(FALSE);
  port_b_pullups(FALSE);
  delay_ms(333);

  //INICIALIZACIONES PERTINENTES A LA APLICACION//
  set_tris_c(0b10000000);      // Habilito como entrada RC7 para canal RS232

  ext_int_edge(0,L_TO_H);      // Configuro captura de 1er flanco de subida
  flagToggleFlanco = 0;        // inicializo el Flag para cambiar de flanco

  enable_interrupts(int_rda);  // Habilito las interrupciones necesarias
  enable_interrupts(int_ext);
  enable_interrupts(global);

  printf("\r\nMidiendo un pulso : Periodo\r\n");
  printf("By Redpic para Foro TODOPIC\r\n\n");

  do
  {
    if (flagHayDatos == 1) // Detecto que ya hay datos de flancos ...
    {   
      if ((t3 > t2) && (t2 > t1))   // Compruebo que estoy en la misma vuelta de TMR1
      {     
        tth = t2 - t1;          // Calculo en Tick's de TMR1 el tiempo en Alto
        ttl = t3 - t2;          // Calculo en Tick's de TMR1 el tiempo en Bajo
        tt = tth + ttl;         // Calculo en Tick's de TMR1 el Periodo del Pulso
        sth = uSxTick * tth;    // Calculo en uS el tiempo.
        stl = uSxTick * ttl;    // Calculo en uS el tiempo.
        st = uSxTick * tt;      // Calculo en uS el tiempo.
        f = 1 / (st / 1000000); // Calculo la Frecuencia
        flagHayTransmitir = 1;    // Indico que tengo nuevo valor para transmitir
      }
      flagHayDatos = 0;           // Indico que ya han sido procesados los datos.
    }
   
    if (Command != 0x00)   // Si he recibido un comando vía Serie ...
    {         
      if (Command == 'T')  // Si el comando es 'T' (Transmite) ...
      {         
        if (flagHayTransmitir == 1) // Si hay algo pendiente de transmitir ...
        {
          printf("Ticks ....... H %4Lu + L %4Lu = %4Lu\r\n", tth, ttl, tt);
          printf("uSegundos ... H %3.1f + L %3.1f = %3.1f F = %4.2f Hz\r\n\n", sth, stl, st, f);
          flagHayTransmitir = 0;  // Indico que ya he transmitido lo pendiente.
        }
      }
      Command = 0x00;             // Indico que ya he procesado el comando.
    }
  } while (TRUE);
}

Gracias otra ves.

Hasta luego  8)

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5415
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 4ª Parte. El pulso completo. El Per
« Respuesta #10 en: 21 de Agosto de 2007, 16:25:50 »
Buenoooo ... primero y muy importante, fundamental diría yo, es que hay definida una constante que te está haciendo que los cálculos te salga erróneos:


float const uSxTick = 0.2; // Microsegundos por Tick de TMR1 a 20 Mhz

Esto viene de 1 (segundo) / 20.000.000 (frecuencia de reloj)* 4 (ciclos de CPU para cada incremento de Timer1)

Como puedes ver esta constante son los microsegundos que tarda en avanzar una posición el Timer1 con un Clock de 20 Mhz .... siempre y cuando el pre-escaler (divisor) del mismo sea 1. Si el divisor es 2 entonces su valor es distinto ya que tardará el doble en incrementar el Timer 1

float const uSxTick = 0.4; // Microsegundos por Tick de TMR1 a 20 Mhz con setup_timer_1(T1_INTERNAL | T1_DIV_BY_2);

Así st = uSxTick * tt; te saldrá correcto.

Cada vez que cambies el divisor del Timer1 multiplica uSxTick por el mismo valor y asi obtendrás el valor correcto.

Para un siguiente post en este mismo hilo voy a preparar esta misma técnica pero contando vueltas completas de Timer1 para no tener que cambiar de preescaler cuando el periodo del pulso a medir sea mayor que el tiempo que tarda el Timer1 en dar una vuelta completa. No es complicado pero me gusta hacer las cosas bien y explicarlas claramente así que lo dejo para el próximo fin de semana que tengo mas tiempo.  :mrgreen:







Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1338
Vaya! si! funciona!! wow!  :P Gracias!!

Ahora el desbordamiento del Timer1 esta en los 26,...

Pero dime una cosa, ¿¿¿en q afecta el poner T1_DIV_BY_1 q poner T1_DIV_BY_2, 4, 8... ???? Segun lo dividido es lo q se va a demorar en avanzar una poscicion el Timer1? No entiendo muy bien eso en lo q afecta. Podrias explicarme un poco mas a detalle porfavor ? 

Nuevamnt disculpa por mi ignorancia pero esq ¡quiero aprender!  :-/ :-/ jeje


salu2 y gracias. 8) 8)

Desconectado psykhon

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 822
Re: Serie Técnicas en C : Midiendo un pulso. 4ª Parte. El pulso completo. El Per
« Respuesta #12 en: 22 de Agosto de 2007, 00:12:46 »
ESCRIBA UN LIBRO MAESTRO!!!!!!!!!!!!!!!
No, no se lo que estoy haciendo. Nadie sabe que estoy haciendo. Por eso se llama "Investigacion".

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1338
Re: Serie Técnicas en C : Midiendo un pulso. 4ª Parte. El pulso completo. El Per
« Respuesta #13 en: 25 de Agosto de 2007, 04:42:22 »
Para un siguiente post en este mismo hilo voy a preparar esta misma técnica pero contando vueltas completas de Timer1 para no tener que cambiar de preescaler cuando el periodo del pulso a medir sea mayor que el tiempo que tarda el Timer1 en dar una vuelta completa. No es complicado pero me gusta hacer las cosas bien y explicarlas claramente así que lo dejo para el próximo fin de semana que tengo mas tiempo.  :mrgreen:
Lo espero ancioso!! yeah!  :-/

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1338
Re: Serie Técnicas en C : Midiendo un pulso. 4ª Parte. El pulso completo. El Periodo
« Respuesta #14 en: 13 de Octubre de 2007, 15:58:29 »
Hola RedPic! queria saber si puedo hacer todo esto igual pero por la interrupcion por cambio de flanco en RB1, yaq el PIC18f2550 tiene ahi un INT1 y en el RB2 un INT2 ¿?¿?¿?¿?

Probe cambiando lo ovio...
Código: [Seleccionar]
#include <18f2550.h>
#fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN
#use delay(clock=20000000)
#use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)


////////////////////////////////////////////////////////////////////////////////////
// Defines y Constantes
////////////////////////////////////////////////////////////////////////////////////
#define LED PIN_B5               //E0 Defino el Pin del Led
#define FLASH Output_Toggle(LED) // Defino la funcion Flash de monitor

float const uSxTick = 0.4;//0.64;//1.6;//0.4;       // Microsegundos por Tick de TMR1 a 20 Mhz


////////////////////////////////////////////////////////////////////////////////////
// Variables en RAM//
////////////////////////////////////////////////////////////////////////////////////
char cRec = 0x00;                      // Último carácter recibido vía serie
char Command = 0x00;                   // Comando a procesar
int8 numFlancoQueLlega = 0;            // Número de Flanco que llega
int1 flagToggleFlanco = 0;             // Flag para cambiar de flanco
int16 t1 = 0x00, t2 = 0x00, t3 = 0x00;       // Variables para guardar estados de ...
int16 tth = 0x00, ttl = 0x00, tt = 0x00;     // Timers y pulsos.
float sth = 0.0, stl = 0.0, st = 0.0, f = 0.00; // Para hacer las restas oportunas en uS
int1 flagHayDatos = 0;                 // Flag para indicar que ya hay datos de ..
                                     // dos flancos (de subida y bajada)
int1 flagHayTransmitir = 0;            // Flag para indicar que hay datos para ...
                                     // Transmitir al PC.


////////////////////////////////////////////////////////////////////////////////////
// Interrupción por Recepción Serie RS232
////////////////////////////////////////////////////////////////////////////////////
#int_rda
void handle_rda_int()
{
  if (kbhit())    // Si hay algo pdte de recibir ...
  {             
    cRec = getc();             // lo recibo sobre cRec ...
    if (cRec != 0x00)       // Si es distinto de \0 ...
    {
      Command = ToUpper(cRec); // cargo cRec sobre Command para procesarlo
    }                        // pasándolo a Mayúsculas para no confundir.
  }
}

////////////////////////////////////////////////////////////////////////////////////
// Interrupción por Externa por Cambio de Flanco en RB0
////////////////////////////////////////////////////////////////////////////////////
#int_ext1
void handle_ext_int()
{

   output_low(pin_b5);
   ++numFlancoQueLlega;     // Cuento flanco que nos llega
 
   if (flagToggleFlanco == 0)  // He recibido Flanco de Subida
   {
      if (numFlancoQueLlega == 1)
      {
         set_timer1(0);       // Reinicio TMR1
         t1=get_timer1();     // Guardo en t1 el valor de TMR1 al primer Flanco de Subida
      }
      if(numFlancoQueLlega == 3)
      {
         t3 = get_timer1();     // Guardo en t1 el valor de TMR1 al primer Flanco de Subida     
         if (flagHayDatos == 0)  // Si los datos anteriores han sido procesados ...
         {
         flagHayDatos = 1;    // Indico que ya hay nuevos datos de flancos para calcular
         }
      }
      ext_int_edge(1, H_TO_L); // Configuro para capturar siguiente flanco de Bajada
      flagToggleFlanco = 1;     // Indico que el siguiente flanco será de Bajada
   }
   else                     // He recibido Flanco de Bajada
   {                 
      t2=get_timer1();        // Guardo en t2 el valor de TMR1 al Flanco de Bajada
      ext_int_edge(1, L_TO_H); // Configuro para capturar siguiente flanco de subida
      flagToggleFlanco = 0;     // Indico que el siguiente flanco será de Subida
   }
 
   //FLASH;                    // Reproduzco la entrada mediante un LEd en E0;
 
   if (numFlancoQueLlega == 3) //Reinicio el Flag q llega para poder leer otro pulso.
   {
      numFlancoQueLlega=0;
   }
}

////////////////////////////////////////////////////////////////////////////////////
// Inicio Programa.
////////////////////////////////////////////////////////////////////////////////////
void main()
{
   //INICIALIZACIONES GENERALES//
   delay_ms(333); // Espero a que todo se estabilice e ...
   disable_interrupts(global); // Inicializo el Micro y ...
   disable_interrupts(int_timer1); // deshabilitando todo lo no necesario ...
   disable_interrupts(int_rda);
   disable_interrupts(int_ext);
   disable_interrupts(int_ext1);
   disable_interrupts(int_ext2);
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_spi(FALSE);
   //setup_psp(PSP_DISABLED);  //Para 18F4550.
   setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
   setup_timer_0(RTCC_OFF);
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_2);
   setup_timer_2(T2_DISABLED,0,1);
   setup_timer_3(T3_DISABLED);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   port_b_pullups(FALSE);
   delay_ms(333);

   //INICIALIZACIONES PERTINENTES A LA APLICACION//
   set_tris_c(0b10000000);      // Habilito como entrada RC7 para canal RS232
 
   ext_int_edge(1,L_TO_H);      // Configuro captura de 1er flanco de subida
   flagToggleFlanco = 0;        // inicializo el Flag para cambiar de flanco

   enable_interrupts(int_rda);  // Habilito las interrupciones necesarias
   enable_interrupts(int_ext1);
   enable_interrupts(global);

   output_high(PIN_B5);
   printf("\r\nMidiendo un pulso : Periodo\r\n");
   printf("By Redpic para Foro TODOPIC\r\n\n");

   do
   {     
    } while (TRUE);
}
Algo falta en los fusibles? no se puede?..... q esta mal ?  :?


salu2 y gracias 8) 8)


 

anything