TÉCNICAS  EN C

Tareas Comunes Realizadas en C

  Midiendo un pulso. 1ª Parte. Tiempo en Alto mediante INTEXT

• 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 tensión 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 vamos a 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 de Bajada).

• 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.

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

• Para medir el ancho W del pulso que permanece en Alto vamos a utilizar dos recursos de los que disponen la inmensa mayoría de los PIC's, tanto los de la serie 18F como los 16F:

• El TIMER1 y la Interrupción 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 continúa de nuevo por 0x0000, y así hasta el infinito y mas allá. (Cuando pasa de 0xFFFF a 0x0000 genera una Interrupción por Desbordamiento de Timer pero que no vamos a utilizar en este ejemplo, así que no vamos a entrar en cómo 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.

• 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 Interrupción Externa por RB0, conocida como INTEXT consiste en una petición de interrupción que se produce al recibir por RB0 un flanco de subida o bajada determinado, que es configurable por nuestro firmware.

• Podemos así fijar un tipo de flanco a detectar y escribir un cierto código para ejecutarlo cuando ese tipo de flanco, subida o bajada, es detectado. Es lo que conocemos como Petición de Servicio por Interrupción (Interrupt Service Request ó ISR)

• En este código ISR escrito para tratar la interrupción externa por RB0 podemos mantener o cambiar el flanco a detectar, cambiándolo 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 exactamente es:
 

• 1.- Configuraremos la INTEXT 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 INTEXT 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 INTEXT por RB0 para detectar de nuevo un Flanco de Subida. 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 número de Tick's de TIMER1 por el tiempo que dura cada Tick (dependiente del cristal que usemos) tendremos el Tiempo W que estamos buscando.

• 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:

   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_ext); // Habilito las interrupciones necesarias
   enable_interrupts(global);

• 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:

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

• 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 limitación que nos impone el no tener en cuenta vueltas completas de TIMER1 para realizar nuestros cálculos: 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 así su desborde.

• Para computar tiempos de pulso mayores 13,1072 milisegundos solo habría que computar también cuantas veces se desborda 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:

• Con todo esto el programa completo para nuestro Detector de Tiempo en Alto de un Pulso queda así: