67369658 formas de medir un pulso con pic

7/29/2019 67369658 Formas de Medir Un Pulso Con Pic

1/24

Midiendo un pulso. 1 Parte. Tiempo en Alto con INTEXT

A.- Conceptos involucrados:

Los pulsos corren alocados entre dos estados conocidos: Alto y Bajo. Es lo que

conocemos como un Tren de Pulsos.

El bajo (Low) cuando la tensin aplicada al Pin est cerca de GND y el otro, el Alto

(High), cuando se parece a VCC. A todos los efectos para nuestras aplicaciones vamosa considerarlos como GND y VCC respectivamente.

Cuando el estado pasa de Bajo a Alto decimos que nos ha llegado un Flanco de Subida

(Raising Edge).

Cuando por el contrario el estado pasa de Alto a bajo entonces decimos que nos llega un

Flanco de Bajada (Falling Edge).

Un Pulso (Pulse) es lo que ocurre entre uno y otro Flancos de Subida sucesivos (o deBajada).

El Tiempo T que transcurre ente dos flancos sucesivos de subida (o de bajada) es lo queconocemos 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.

Al Tiempo que permanece un pulso en Alto que es lo que vamos a llamar Ancho delPulso (Pulse Width) y es el tiempo que pretendemos medir. W en el esquema inferior.

B.- Tcnica a Aplicar:

Para medir el ancho W del pulso que permanece en Alto vamos a utilizar dos recursos

de los que disponen la inmensa mayoria de los PIC's, tanto los de la serie 18F como los

16F:

El TIMER1 y la Interrupcin Externa por RB0.

*El TIMER1 es un contador de 16 bits que se incrementa cada 4 ciclos de Reloj

(FOSC /4). A este tiempo le vamos a llamar Tick de TIMER1.

Cuando el TIMER1 alcanza el valor 0xFFFF contina de nuevo por 0x0000, y as

hasta el infinito y mas all. (Cuando pasa de 0xFFFF a 0x0000 genera una Interrupcin

por Desbordamiento de Timer pero que no vamos a utilizar en este ejemplo, as que no

vamos a entrar en cmo funciona).

Si el cristal de cuarzo con el calzamos nuestro PIC es de 20 Mhz, por ejemplo, entonces

cada 4 * 1/20.000.000 = 0,0000002 segundos (0.2 microsegundos) se produce un Tick

de TIMER1.


2/24

De igual forma una vuelta completa del TIMER1, desde 0x0000 hasta 0xFFFF (65536

pasos), ocupa un tiempo total de 0,0000002 * 65.536 = 0,0131072 segundos (13,1072

milisegundos)

*La Interrupcin Externa por RB0, conocida como Int_Ext consiste en una peticin

de interrupcin que se produce al recibir por RB0 un flanco de subida o bajadadeterminado, que es configurable por nuestro firmware.

Podemos as fijar un tipo de flanco a detectar y escribir un cierto cdigo paraejecutarlo cuando ese tipo de flanco, subida o bajada, es detectado. Es lo que

conocemos como Peticin de Servicio por Interrupcin (Interrupt Service Request ISR)

En este cdigo ISR escrito para tratar la interrupcin externa por RB0 podemos

mantener o cambiar el flanco a detectar, cambindolo del de Subida al de Bajada o

viceversa y leer o escribir el valor de TIMER1 que en ese momento tiene el contador.

* 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 configuracin de la Int_Ext por RB0 para detectar el siguienteFlanco 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 deSubida. Y ...

6.- Con estos dos valores de TIMER1 tendremos, expresados en Tick's de TIMER1,restando el segundo del primero, el tiempo que ha permanecido en alto el Pulso.

Multiplicando dicho nmero de Tick's de TIMER1 por el tiempo que dura cada Tick

(dependiente del cristal que usemos) tendremos el Tiempo W que estamos buscando.

C.- Implementacin en C:

Para implementar nuestro Cdigo en C vamos a centrarnos en los puntos que hemosdescrito en la seccin anterior.

Para configurar inicialmente el flanco de subida a detectar utilizaremos:

CdigoGeSHi (c):

1. ext_int_edge(0,L_TO_H); // Configuro capturade 1er flanco de subida

2. flagToggleFlanco = 0; // inicializo elFlag para cambiar de flanco

3. enable_interrupts(int_ext); // Habilito lasinterrupciones necesarias

4. enable_interrupts(global);5.


3/24

Hemos aadido la variable int1 flagToggleFlanco debido a que una vez establecido elflanco 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 deSubida y si por el contrario flagToggleFlanco tiene un valor de 1 entonces es el de

bajada el que esperamos.

Con esta configuracin inicial podemos ya escribir nuestra rutina ISR:

CdigoGeSHi (c):

1. #int_ext2. void handle_ext_int(){3.4. if(flagToggleFlanco==0){ // He recibido

Flanco de Subida

5.6. t1=get_timer1(); // Guardo en t1 elvalor de TMR1 al Flanco de Subida

7. ext_int_edge(0,H_TO_L); // Configuro paracapturar siguiente flanco de Bajada

8. flagToggleFlanco=1; // Indico que elsiguiente flanco ser de Bajada

9.10. }else{ // He recibido

Flanco de Bajada11.12. t2=get_timer1(); // Guardo en t2 el

valor de TMR1 al Flanco de Bajada

13.

ext_int_edge(0,L_TO_H); // Configuro paracapturar siguiente flanco de subida14. flagToggleFlanco=0; // Indico que el

siguiente flanco ser de Subida15. set_timer1(0); // Reinicio TMR116. if(flagHayDatos==0){ // Si los datos

anteriores han sido procesados ...17. flagHayDatos=1; // Indico que ya

hay nuevos datos de flancos para calcular18. }19. }20. }21.

Fijaos que en la rutina ISR anterior no realizamos ningn clculo. Aplicamos aqui el

principio fundamental de que "dentro de una rutina de interrupcin haz lo debas y

abandnala lo antes que puedas". Asi que si tenemos valores vlidos de T1 y T2

entonces solo hacemos que flagHayDatos valga 1 y ya trataremos estos valores dentro

de main().

CdigoGeSHi (c):

1. if(flagHayDatos==1){ // Detecto que yahay datos de flancos ...


4/24

2. if(t2 > t1){ // Compruebo queestoy en la misma vuelta de TMR1

3. tt = t2 - t1; // Calculo en Tick'sde TMR1 el tiempo entre flancos

4. st = uSxTick * tt; // Calculo en uS eltiempo.

5.

flagHayTransmitir=1; // Indico que tengonuevo valor para transmitir6. }7. flagHayDatos=0; // Indico que ya han

sido procesados los datos.8. }9.

Cuando flagHayDatos es 1 podemos proceder a calcular los Ticks transcurridos entre

un flanco y otro.

Fijaos que preguntamos si T2 es mayor que T1. Esto es debido a una limitacin que

nos impone el no tener en cuenta vueltas completas de TIMER1 para realizar nuestros

clculos: T2 y T1 deben estar dentro de una misma vuelta de TIMER2, o sea que el

pulso en alto debe ser menor que 13,1072 milisegundos. Notad que cuando detectamos

el segundo 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 habra que

computar tambien cuantas veces se desborada completo TIMER1 y realizar los clculos

aritmticos correspondientes.

Al igual que hacamos en la Rutina ISR en que no calculbamos sino que solo

indicbamos que podamos calcular, aqu una vez realizados los calculos de Ticks y su

equivalencia en segundos no los transmitimos, slo indicamos que hay datos para

transmitir mediante poner a 1 flagHayTransmitir.

Para transmitir el ltimo valor computado vamos a implementar una recepcin va serieRS232 que al recibir el comando 'T' nos enva el ltimo valor correcto registrado:

CdigoGeSHi (c):

1. if(Command!=0x00){ // Si he recibido uncomando va Serie ...

2. if(Command=='T'){ // Si el comando es'T' (Transmite) ...

3. if(flagHayTransmitir==1){ // Si hay algopendiente de transmitir ...

4. printf("Ticks %Lu - %Lu = %Lu = %3.1fuS\r\n",t2,t1,tt,st);

5. flagHayTransmitir=0; // Indico que ya hetransmitido lo pendiente.

6. }7. }8. Command=0x00; // Indico que ya heprocesado el comando.9. }
http://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.html


5/24

10.

Con todo esto el programa completo para nuestro Detector de Tiempo en Alto de un

Pulso queda as:

CdigoGeSHi (c):

1. ////////////////////////////////////////////////////////////////////////////////////

2. //3. // Midiendo_un_pulso_1_Width_High.c4. //5. // SERIE: "Tcnicas en C" para el Foro TODOPIC6. //7. // (c) 10.2006 by RedPic8. //9. // Propsito: Medir el tiempo que permanece un pulso en alto10. //11. // Condiciones de Test: Inyeccin por RB0 de una seal de 2 Khz

(0.5 ms de periodo)12. //13. // Tcnica Empleada: Detectar mediante la Interrupcin Externapor RB0

14. // un flanco de subida de un pulso, guardarel estado

15. // de TMR1, detectar a continuacin elsiguiente

16. // flanco de bajada, guardar el nuevo estadode TMR1,

17. // realizar las substraccin de ambos paraobtener el18. // tiempo que permanece en alto y transmitir

mediante19. // el puerto RS232 a peticin.20. //21. ///////////////////////////////////////////////////////////////

/////////////////////22.23. #include 24. #fuses

HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN

25.#use delay(clock=20000000)26.

27. #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7)28.29. ///////////////////////////////////////////////////////////////

/////////////////////30. //31. // Defines y Constantes32. //33. ///////////////////////////////////////////////////////////////

/////////////////////34.35. #define LED PIN_E0 // Defino el Pin

del Led36. #define FLASH Output_Toggle(LED) // Defino lafuncion Flash de monitor


6/24

37.38. floatconst uSxTick = 0.2; // Microsegundospor Tick de TMR1 a 20 Mhz

39.40. ///////////////////////////////////////////////////////////////

/////////////////////

41.//42. // Variables en RAM

43. //44. ///////////////////////////////////////////////////////////////

/////////////////////45.46. char cRec=0x00; // ltimo caracter

recibido via serie47. char Command=0x00; // Comando aprocesar

48. int1 flagToggleFlanco=0; // Flag paracambiar de flanco

49. int16 t1=0x00,t2=0x00,tt=0x00; // Variables paraguardar estados de ...50. float st=0.0; // TMR1 en cadaflanco y hacer la resta

51. int1 flagHayDatos=0; // Flag paraindicar que ya hay datos de ..

52. // dos flancos (desubida y bajada)

53. int1 flagHayTransmitir=0; // Flag paraindicar que hay datos para ...

54. // Transmitir alPC.

55.56. ///////////////////////////////////////////////////////////////

/////////////////////57. //58. // Interrupcin por Recepcin Serie RS23259. //60. ///////////////////////////////////////////////////////////////

/////////////////////61.62. #int_rda63. void handle_rda_int(){64.65. if(kbhit()){ // Si hay algo pdte

de recibir ...66. cRec=getc(); // lo recibo sobre

cRec ...67. if(cRec!=0x00){ // Si es distinto

de \0 ...68. Command=ToUpper(cRec); // cargo cRec sobre

Command para procesarlo69. } // pasndolo a

Maysculas para no confundir.70. }71. }72.73. ///////////////////////////////////////////////////////////////

/////////////////////74. //75. // Interrupcin por Externa por Cambio de Flanco en RB076. //


7/24

77. ////////////////////////////////////////////////////////////////////////////////////

78.79. #int_ext80. void handle_ext_int(){81.82.

if(flagToggleFlanco==0){ // He recibidoFlanco de Subida

83.84. t1=get_timer1(); // Guardo en t1 el

valor de TMR1 al Flanco de Subida85. ext_int_edge(0,H_TO_L); // Configuro para

capturar siguiente flanco de Bajada86. flagToggleFlanco=1; // Indico que el

siguiente flanco ser de Bajada87.88. }else{ // He recibido

Flanco de Bajada89.90.

t2=get_timer1(); // Guardo en t2 elvalor de TMR1 al Flanco de Bajada

91. ext_int_edge(0,L_TO_H); // Configuro paracapturar siguiente flanco de subida

92. flagToggleFlanco=0; // Indico que elsiguiente flanco ser de Subida

93. set_timer1(0); // Reinicio TMR194. if(flagHayDatos==0){ // Si los datos


hay nuevos datos de flancos para calcular96. }97. }98. FLASH; // Reproduzco la

entrada mediante un LEd en E0;99. }100.101.void main(){102.103. ////////////////////////////////////////// INICIALIZACIONES

GENERALES104.105. delay_ms(333); // Espero a que

todo se estabilice e ...106. disable_interrupts(global); // Inicializo el

Micro y ...107. disable_interrupts(int_timer1); // deshabilitando

todo lo no necesario ...108. disable_interrupts(int_rda);109. disable_interrupts(int_ext);110. disable_interrupts(int_ext1);111. disable_interrupts(int_ext2);112. setup_adc_ports(NO_ANALOGS);113. setup_adc(ADC_OFF);114. setup_spi(FALSE);115. setup_psp(PSP_DISABLED);116. setup_counters(RTCC_INTERNAL,RTCC_DIV_2);117. setup_timer_0(RTCC_OFF);118. setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);119. setup_timer_2(T2_DISABLED,0,1);120. setup_timer_3(T3_DISABLED);121. setup_comparator(NC_NC_NC_NC);


8/24

122. setup_vref(FALSE);123. port_b_pullups(FALSE);124. delay_ms(333);125.126. /////////////////////////////////////////// INICIALIZACIONES

PERTINENTES A LA APLICACION

127.

128. set_tris_c(0b10000000); // Habilito comoentrada RC7 para canal RS232

129.130. ext_int_edge(0,L_TO_H); // Configuro

captura de 1er flanco de subida131. flagToggleFlanco = 0; // inicializo el

Flag para cambiar de flanco132.133. enable_interrupts(int_rda); // Habilito las

interrupciones necesarias134. enable_interrupts(int_ext);135. enable_interrupts(global);136.

137. printf("\r\nMidiendo un pulso : Width High\r\n");138. printf("By Redpic para Foro TODOPIC\r\n\n");139.140. do{141.142. if(flagHayDatos==1){ // Detecto que ya

hay datos de flancos ...143. if(t2 > t1){ // Compruebo que

estoy en la misma vuelta de TMR1144. tt = t2 - t1; // Calculo en

Tick's de TMR1 el tiempo entre flancos145. st = uSxTick * tt; // Calculo en uS el

tiempo.146. flagHayTransmitir=1; // Indico que tengo

nuevo valor para transmitir147. }148. flagHayDatos=0; // Indico que ya

han sido procesados los datos.149. }150. if(Command!=0x00){ // Si he recibido

un comando va Serie ...151. if(Command=='T'){ // Si el comando es

'T' (Transmite) ...152. if(flagHayTransmitir==1){ // Si hay algopendiente de transmitir ...

153.154. printf("Ticks %Lu - %Lu = %Lu = %3.1fuS

\r\n",t2,t1,tt,st);155.156. flagHayTransmitir=0; // Indico que ya he

transmitido lo pendiente.157. }158. }159. Command=0x00; // Indico que ya heprocesado el comando.

160. }161. }while(TRUE);162.}163.
http://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.html


9/24

Seguimos dndole vueltas al Tema de Capturar el ancho de un pulso ...

EnMidiendo un pulso. 1 Parte. Tiempo en Alto con INTEXThemos utilizado la

tcnica de recoger el valor de TMR1 cuando ocurre la interrupcin externa por RB0, sea

en el flanco de cada, sea en el de subida. Con los valores de ambos flancos y

simplemente restando el uno del otro tenemos el valor del ancho del pulso.

Hay otra manera de hacer exactamente lo mismo de una forma absolutamente similar:

Utilizando el mdulo CCP del PIC funcionando en modo Capture.


Los conceptos son exactamente los mismos que los descritos en la parte anterior por lo

que os ruego que consultis si os es necesario:Midiendo un pulso. 1 Parte


El mdulo hardware CCP del PIC en configuracin Capture realiza de forma automtica

(por hardware) lo que implementamos en nuestro anterior Tcnica en C mediante la

interrupcin externa por RB0.

Cuando activamos el mdulo CCP, le configuramos el flanco que deseamos que lo

dispere, subida o bajada, automticamente cada vez que se nos presente dicho flanco en

el pin correspondiente se copia el valor de TMR1, de 16 bits, en la pareja de registros

CCPRL y CCPRH.

Cada vez que llega un flanco tenemos en CCPR el valor en ese momento de TMR1.

Si adems habilitamos la Interrupcin CCP del PIC se producir adems una Peticin de

Servicio para esta interrupcin cada vez que nuestro esperado flanco se presente en el

pin correspondiente.

En esta rutina de interrupcin podremos as cambiar el modelo de flanco a utilizar para

el siguiente disparo del CCP, cambindolo ahora al flanco de bajada, y as en el

siguiente disparo tendremos en CCPR el nuevo valor de TIMER1 con lo restando ste

del anterior tendremos el ancho de pulso en High que deseamos.

Como vis es absolutamente identico al mtodo anterior pero sin tener que recoger "amano" el valor de TMR1.


Nota Importante: En mi ejemplo utilizo el 18F4550 de laRRBOARD2usando del

mdulo CCP2, de los dos que tiene este PIC, configurndolo adems para que CCP2 en

lugar de estar en RC1 como originalmente est configurado y que estoy usando para

otras cosas, se multiplexe por RB3 que lo tengo libre. Esto ltimo se consigue en el

18F4550 usando el fuse CCP2B3.

Para configurar inicialmente el flanco de subida a detectar utilizaremos:
http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=2300.0http://www.todopic.com.ar/foros/index.php?topic=2300.0http://www.todopic.com.ar/foros/index.php?topic=2300.0http://www.todopic.com.ar/foros/index.php?topic=2300.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0


10/24

CdigoGeSHi (c):

1. setup_ccp2(CCP_CAPTURE_RE); // Configuro captura de 1erflanco de subida

2. flagToggleFlanco = 0; // inicializo el Flag paracambiar de flanco

3. enable_interrupts(int_ccp2);4. enable_interrupts(global);5.

Nuestra rutina ISR para CCP quedara como sigue:

CdigoGeSHi (c):

1. #int_ccp22. void handle_ccp2_int(){3. if(flagToggleFlanco==0){ // He recibido

Flanco de Subida4. t1=CCP_2; // Guardo la captura del

CCP2 al Flanco de Subida5. setup_ccp2(CCP_CAPTURE_FE); // Configuro para



Flanco de Bajada9.10. t2=CCP_2; // Guardo en t2 la nuevacaptura de CCP2 al Flanco de Bajada11. setup_ccp2(CCP_CAPTURE_RE); // Configuropara capturar siguiente flanco de subida

12. flagToggleFlanco=0; // Indico que elsiguiente flanco ser de Subida

13. if(flagHayDatos==0){ // Si los datosanteriores han sido procesados ...

14. flagHayDatos=1; // Indico que yahay nuevos datos de flancos para calcular

15. }16. }17.

El resto de la implementacin en C de esta Tcnica es identica a la mostrada en

Midiendo un pulso. 1 Parte. Tiempo en High con Int_Ext

D.- Ejemplo funcionando:
http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0


11/24

La seal inyectada podis verla en :


12/24

Bueno, y esto es todo por hoy amigos.


13/24

Y por fin le damos una vuelta de tuerca al Tema de Capturar el ancho de un pulso ...

Por indicacin del amigo filth ampliamos lo que hemos visto enMidiendo un pulso. 1

Parte. Tiempo en Alto con INTEXTy enMidiendo un pulso. 2 Parte. Tiempo en Alto

con INTCCP.

En ambas hemos utilizado la tcnica de recoger el valor de TMR1 cuando ocurre o la

interrupcin externa por RB0 o la interrupcion CCP, sea en el flanco de cada, sea en el

de subida. Con los valores de ambos flancos y simplemente restando el uno del otro

tenemos el valor del ancho del pulso.

Hay otra manera de hacer exactamente lo mismo utilizando una tercera fuente de

interrupcin de los PIC's: Utilizando la intetrrupcin por cambio de estado de

RB04:7


Los conceptos son exactamente los mismos que los descritos en las parte anteriores por

lo que os ruego que consultis si os es necesario:Midiendo un pulso. 1 Partey/o2

Parte.


La interrupcin por Cambio de Estado de los pines 4 a 7 del PORTB es una

interrupcin muy socorrida aunque algo falta de precisicin. No dispone como ennuestros anteriores ejemplos INTEXT e INTCCP de la posibilidad de pre-programar el

flanco que deseamos que dispare la Peticin de Servicio de Interrupcin (ISR).

Aunque esta interrupcin, a la que a partir de aqu llamaremos INTRB, afecta enprincipio a los bits desde el 4 hasta el 7 del PORTB, solo lo har efectivamente a

aquellos que esten configurados como de entrada, que hayamos programado con el

TRIS a 1.

Al dispararse la interrupcin solo sabemos que uno o mas de estos pines ha cambiado

de estado. Nada mas, ni nada menos.

Por ello es imprescindible al usar INTRB que vayamos recogiendo sobre una variable

esttica de un byte los cambios sucesivos que se van produciendo para poder compararen el momento de recibir la interrupcin el estado actual del PORTB con el

inmediatamente anterior.

As si el bit correspondiente al pin que estamos utilizando para nuestra medicin del

pulso es igual en el estado actual que en el anterior no tenemos cambio en el pulso yadems no ha sido ste pin el responsable de disparar la interrupcin.

Si el estado anterior era bajo y el actual es alto estamos ante el flanco de subida de

nuestro pulso y adems es l quien ha producido el disparo de la interrupcin.

Si por el contrario el estado anterior del pin era alto y ahora es bajo entoncesacabamos de detectar el flanco de bajada de nuestro pulso, y por supuesto tambin ha
http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0


14/24

sido l el responsable de disparar la interrupcin INTRB.

Con esta informacin realizaremos exactamente igual que en los ejemplos anteriores:

guardamos el valor de TMR1 tras el flanco de subida y tras el de bajada, realizamos la

correspondiente resta entre ambos valores y transmitimos los resultados.


Para configurar inicialmente nuestra interrupcin INTRB debemos hacer que nuestropin, en este caso el 4, sea de entrada, y habilitaremos las interrupciones necesarias con:

CdigoGeSHi (c):

1. set_tris_b(0b00010000); // Habilito comoentrada RB7 para interrupcin RB

2. enable_interrupts(int_rb);3. enable_interrupts(global);4.

Nuestra rutina ISR para INTRB quedara como sigue:

CdigoGeSHi (c):

1. int estado_portb_anterior=0;2. int estado_portb_actual=0;3.4. ...5.6. #int_rb7. void handle_rb_int(){8.9. estado_portb_actual=input_b();10. if

((!bit_test(estado_portb_anterior,4))&&(bit_test(estado_portb_actual,4)))

11. {12. hay_flanco_de_bajada=0;13. }14.15. if(hay_flanco_de_bajada!=0){ // He recibido

Flanco de Subida16. t1=get_timer1(); // Guardo en t1 el

valor de TMR1 al Flanco de Subida17. }else{ // He recibido

Flanco de Bajada18. t2=get_timer1(); // Guardo en t2 el

valor de TMR1 al Flanco de Bajada19. set_timer1(0); // Reinicio TMR120. if(flagHayDatos==0){ // Si los datos


hay nuevos datos de flancos para calcular

22. }23. }


15/24

24. }25.

El resto de la implementacin en C de esta Tcnica es identica a la mostrada en

Midiendo un pulso. 1 Parte. Tiempo en Alto con INTEXT yMidiendo un pulso. 2Parte. Tiempo en Alto con INTCCP

Bueno, y esto es todo por hoy amigos.
http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14479.0http://www.todopic.com.ar/foros/index.php?topic=14428.0


16/24

Midiendo un pulso. 4 Parte. El pulso completo. El Periodo y la Frecuencia


Si lo creis oportuno podis antes darle un repaso a la misma seccin de Conceptos de

la parte 1 de esta Tcnica en C :Tiempo en Alto. Los coceptos son los mismos y aqusolo vamos a hacer algunas consideraciones sobre los mismos.

Decamos all que el Tiempo T que transcurre ente dos flancos sucesivos de subida (ode 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 loexpresamos 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.


Para medir el periodo T del pulso vamos a utilizar los dos mismos recursos que en la 1

parte de este artculo, 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 Interrupcin Externa por RB0.

Para ver los detalles de estos recursos dadle tambin un vistazo a la primera parte de

esta Tcnica en C1 Parte. Tiempo en High.

(Quito este trozo para no sobrepasar los lmites de un Post que nos impone el Foro )

Aunque para calcular el Periodo del pulso y/o su Frecuencia no es necesario tomar elTiempo T2 intermedio del Flanco de Bajada, ya que solo nos son necesarios T1 y T3,
http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0http://www.todopic.com.ar/foros/index.php?topic=14428.0


17/24

los dos flancos de Subida sucesivos, vamos a calcularlos todos ya que as tendremos

tambin cunto 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 configuracin 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 tambin 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

nmero 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 obtendramos la

frecuencia del Pulso.


Para implementar nuestro Cdigo en C vamos a centrarnos en los puntos que hemos

descrito en la seccin anterior.

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

CdigoGeSHi (c):

1. ext_int_edge(0,L_TO_H); // Configuro capturade 1er flanco de subida

2. flagToggleFlanco = 0; // inicializo elFlag para cambiar de flanco

3. enable_interrupts(int_ext); // Habilito lasinterrupciones necesarias

4. enable_interrupts(global);5.

Hemos aadido la variable int1 flagToggleFlanco debido a que una vez establecido elflanco 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 deSubida y si por el contrario flagToggleFlanco tiene un valor de 1 entonces es el de

bajada el que esperamos.

Con esta configuracin inicial podemos ya escribir nuestra rutina ISR:


18/24

CdigoGeSHi (c):

1. #int_ext2. void handle_ext_int(){3.4. ++numFlancoQueLlega; // Cuento flanco que

nos llega5. if(flagToggleFlanco==0){ // He recibido

Flanco de Subida6. if(numFlancoQueLlega==1){7. set_timer1(0); // Reinicio TMR18. t1=get_timer1(); // Guardo en t1 el

valor de TMR1 al primer Flanco de Subida9. }10. if(numFlancoQueLlega==3){11. t3=get_timer1(); // Guardo en t1 el

valor de TMR1 al primer Flanco de Subida12. if(flagHayDatos==0){ // Si los datos


hay nuevos datos de flancos para calcular14. }15. }16. ext_int_edge(0,H_TO_L); // Configuro para


siguiente flanco ser de Bajada18. }else{ // He recibido

Flanco de Bajada19. t2=get_timer1(); // Guardo en t2 el

valor de TMR1 al Flanco de Bajada

20. ext_int_edge(0,L_TO_H); // Configuro paracapturar siguiente flanco de subida21. flagToggleFlanco=0; // Indico que el

siguiente flanco ser de Subida22. }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 ningn clculo. Aplicamos aqui el

principio fundamental de que "dentro de una rutina de interrupcin haz lo debas y

abandnala lo antes que puedas". Asi que si tenemos valores vlidos de T1, T2 y T3

entonces solo hacemos que flagHayDatos valga 1 y ya trataremos estos valores dentrode main().

Con numFlancoQueLlega sabremos qu flanco de Subida es T1 y cal es T3 ya que solo

cuando obtengamos T3 daremos por concluida nuestra captura.

Cdigo

GeSHi (c):


19/24

1. if(flagHayDatos==1){ // Detecto que yahay datos de flancos ...

2. if((t3>t2)&&(t2>t1)){ // Compruebo queestoy en la misma vuelta de TMR1

3. tth = t2 - t1; // Calculo en Tick'sde TMR1 el tiempo en Alto

4.

ttl = t3 - t2; // Calculo en Tick'sde TMR1 el tiempo en Bajo5. tt = tth + ttl; // Calculo en Tick's

de TMR1 el Periodo del Pulso6. 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

Frecuencia10. flagHayTransmitir=1; // Indico que tengo


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 limitacin que nos impone el no tener en cuenta vueltas completas

de TIMER1 para realizar nuestros clculos: 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 habra que

computar tambien cuantas veces se desborada completo TIMER1 y realizar los clculos

aritmticos correspondientes.

Al igual que hacamos en la Rutina ISR en que no calculbamos sino que soloindicbamos que podamos calcular, aqu una vez realizados los calculos de Ticks y su

equivalencia en segundos no los transmitimos, slo indicamos que hay datos para

transmitir mediante poner a 1 flagHayTransmitir.

Para transmitir el ltimo valor computado vamos a implementar una recepcin va serieRS232 que al recibir el comando 'T' nos enva el ltimo valor correcto registrado:

CdigoGeSHi (c):

1. if(Command!=0x00){ // Si he recibido uncomando va Serie ...


20/24

2. if(Command=='T'){ // Si el comando es'T' (Transmite) ...

3. if(flagHayTransmitir==1){ // Si hay algopendiente 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


10. }11.

Con todo esto el programa completo para nuestro Detector de Periodo y Frecuencia

de un Pulso queda as:

CdigoGeSHi (c):

1. ////////////////////////////////////////////////////////////////////////////////////

2. //3. // Midiendo_un_pulso_2_Complete.c4. //5. // SERIE: "Tcnicas en C" para el Foro TODOPIC6. //7. // (c) 10.2006 by RedPic8. //9. // Propsito: Medir los tiempos en alto y bajo que permanece unpulso : Periodo y Frecuencia

10. //11. // Condiciones de Test: Inyeccin por RB0 de una seal de 2 Khz

(0.5 ms de periodo)12. //13. // Tcnica Empleada: Detectar mediante la Interrupcin Externapor RB0

14. // un flanco de subida de un pulso, guardarel estado

15. // de TMR1, detectar a continuacin elsiguiente16. // flanco de bajada, guardar el nuevo estadode TMR1,

17. // detectar a continuacin un nuevo flanco desubida,

18. // guardar nuevamente el estado de TMR1 yrealizar la

19. // correspondiente substraccin de ellos paraobtener

20. // el tiempo que permanece en alto y bajo ytransmitir

21. // los resultados mediante el puerto RS232 apeticin.

22.//23. ///////////////////////////////////////////////////////////////

/////////////////////
http://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.html


21/24

24.25.26. #include 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 Constantes36. //37. ///////////////////////////////////////////////////////////////

/////////////////////38.39.

#define LED PIN_E0 // Defino el Pindel Led

40. #define FLASH Output_Toggle(LED) // Defino lafuncion Flash de monitor

41.42. floatconst uSxTick = 0.2; // Microsegundospor Tick de TMR1 a 20 Mhz

43.44.45. ///////////////////////////////////////////////////////////////

/////////////////////46. //47. // Variables en RAM48. //49. ///////////////////////////////////////////////////////////////

/////////////////////50.51. char cRec=0x00; // ltimo caracter

recibido via serie52. char Command=0x00; // Comando aprocesar

53. int8 numFlancoQueLlega=0; // Nmero de Flancoque llega

54. int1 flagToggleFlanco=0; // Flag paracambiar de flanco

55. int16 t1=0x00,t2=0x00,t3=0x00; // Variables paraguardar 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 uS58. 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. //


22/24

65. // Interrupcin por Recepcin Serie RS23266. //67. ///////////////////////////////////////////////////////////////

/////////////////////68.69.70.

#int_rda71. 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 procesarlo77. } // pasndolo a

Maysculas para no confundir.

78.

}79. }80.81. ///////////////////////////////////////////////////////////////

/////////////////////82. //83. // Interrupcin por Externa por Cambio de Flanco en RB084. //85. ///////////////////////////////////////////////////////////////

/////////////////////86.87.88. #int_ext89. void handle_ext_int(){90.91. ++numFlancoQueLlega; // Cuento flanco

que nos llega92.93. if(flagToggleFlanco==0){ // He recibido

Flanco de Subida94.95. if(numFlancoQueLlega==1){96. set_timer1(0); // Reinicio TMR197. t1=get_timer1(); // Guardo en t1 el

valor de TMR1 al primer Flanco de Subida98. }99. if(numFlancoQueLlega==3){100. t3=get_timer1(); // Guardo en t1 el

valor de TMR1 al primer Flanco de Subida101. if(flagHayDatos==0){ // Si los datos


hay nuevos datos de flancos para calcular103. }104. }105. ext_int_edge(0,H_TO_L); // Configuro para



Flanco de Bajada


23/24

109.110. t2=get_timer1(); // Guardo en t2 el

valor de TMR1 al Flanco de Bajada111. ext_int_edge(0,L_TO_H); // Configuro para

capturar siguiente flanco de subida112. flagToggleFlanco=0; // Indico que el

siguiente flanco ser de Subida113. }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

GENERALES126.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 APLICACION149.150. set_tris_c(0b10000000); // Habilito como

entrada RC7 para canal RS232151.152. ext_int_edge(0,L_TO_H); // Configuro

captura de 1er flanco de subida153. flagToggleFlanco = 0; // inicializo el

Flag para cambiar de flanco154.155. enable_interrupts(int_rda); // Habilito las

interrupciones necesarias156. enable_interrupts(int_ext);


24/24

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 TMR1166. tth = t2 - t1; // Calculo en

Tick's de TMR1 el tiempo en Alto167. ttl = t3 - t2; // Calculo en

Tick's de TMR1 el tiempo en Bajo168. tt = tth + ttl; // Calculo en

Tick's de TMR1 el Periodo del Pulso169. sth = uSxTick * tth; // Calculo en uS el

tiempo.

170.

stl = uSxTick * ttl; // Calculo en uS eltiempo.171. st = uSxTick * tt; // Calculo en uS el

tiempo.172. f = 1 / (st / 1000000); // Calculo la

Frecuencia173.174. flagHayTransmitir=1; // Indico que tengo


han sido procesados los datos.177. }178. if(Command!=0x00){ // Si he recibido

un comando va Serie ...179. if(Command=='T'){ // Si el comando es

'T' (Transmite) ...180. if(flagHayTransmitir==1){ // Si hay algopendiente 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


189. }190.191.192. }while(TRUE);193.}194.

D.- Ejemplo funcionando:
http://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.htmlhttp://www.opengroup.org/onlinepubs/009695399/functions/printf.html

67369658 formas de medir un pulso con pic

Documents