Detectando Flancos de subida (y de bajada) con un 18F4550

[RedPic]

Lo tengo "casi" todo, y ese "casi" hace que esté contento con el resto. Quiero tenerlo todo y vamos a ver si con vuestra ayuda lo logro porque me tiene desconcertado. 

Introducción:

Los que me conocéis de antiguo estáis al tanto de un proyecto que acometí cuando mis conocimientos de los PIC's no eran los que son hoy, que no es que sean muchos pero si que son bastantes mas que en aquella época.

El proyecto era el Analizador lógico de 3 Canales y a pesar de todo me siento me siento muy orgulloso de él que sin embargo era difícil de manejar, sobre todo a la hora de iniciar el "sensado" y también después en el PC que había que "tratar" los datos recibidos para una correcta visualización.

Además de haber, digamos, "ampliado" el tema con cosas como la Serie Técnicas en C y los Decodificando el protocolo ABA Track 2 y el El Protocolo Wiegand explicado que tratan mas o menos con el mismo asunto.

Decidí hace poco re-acometer el tema pero empezando de nuevo desde el principio, de forma mas simple, con un paso intermedio de transmisión de datos en un formato en que no hiciese falta un Software especial, como mi Analyzer realizado en Delphi, sino que en modo texto pudiesen recogerse las medidas y que después pudiesen ser tratadas algebraica o gráficamente con cualquier programa "ad hoc", incluso con el mio en Delphi pero no solo con él.

Me he tirado a la piscina y he empezado con el asunto, leyendo flancos de subida (y de bajada) y transmitiendo los resultados vía serie para poder recogerlos en el PC y guardarlos en modo texto. Después veré que hago con los datos y con qué software.

Lo primero es lo primero y eso es lo que he atacado, recoger flancos, guardarlos y transmitirlos.

Procedimiento

Aunque mas abajo os pongo el fuente en CCS de lo que llevo hecho primero os describiré lo que he implementado.

Utilizo un 18F4550 rodando a 48 Mhz, usando la PLL para obtener la máxima velocidad posible. A esta velocidad el Timer1 de 16 bits tiene un ciclo de Tick de 0.0833 uS y un desborde (Overflow) de 5,461333 mS.

Los distintos desbordes del Timer1 los recojo sobre una variable con la #int_timer1.

Senso al inicio los PIN_B0, PIN_B1 y PIN_B2 para conocer su estado y con esta información configuro las #int_ext, #int_ext1 y #int_ext2 de forma que interrumpan a la llegada del flanco correspondiente al cambio al estado contrario. Así si leo un H en PIN_B0 configuro #int_ext para H_TO_L y si leo al inicio un L la configuro para recibir el flanco L_TO_H.

A partir de ahí habilito las tres interrupciones mas la del Timer1 y me quedo a la espera de la llegada de los distintos flancos, sean estos los que sean. Cuando llega el primero, por cualquiera de los tres canales pongo a cero tanto el Timer1 como el contador de Overflows del Timer1 para que los distintos flancos sean recogidos en unidades de tiempo de distancia del Timer1 con respecto a ese primer flanco.

Tengo en RAM tres ARRAYS donde voy a guardar los datos de cada flanco cuando llegue por cada una de las tres interrupciones. Estos datos van a ser:

• Canal por el que llega (1,2 ó 3) y si es L_TO_H ó H_TO_L
• Valor del Timer1 (16 bits) en el momento de su llegada
• Número de Desbordes del Timer1 ocurridos en el momento de su llegada

Cada vez que llega un flanco Conmuto la interrupción correspondiente al flanco contrario y me tomo nota del siguiente flanco que estoy esperando.

Cuando lo estimo oportuno le pido al PIC que me envíe los datos y entonces vuelca la información recogida en los ARRAYS al canal serie y puedo o visualizarlos o recogerlos en el PC.

El formato es:

<D,Index,Channel,Overflows,Timer>

Con estos datos es fácil calcular el tiempo de llegada de cada flanco ya que es:

timeF = (Overflows * 5461,333 uS) + (Timer  0.0833 uS) expresado en microsegundos.

Aquí tenéis un ejemplo de una lectura realizada en la que se ven datos de los tres canales:



Paso ahora a mostraros el código fuente pertinente que he escrito:

Fuses y configuración:

Código

GeSHi (csharp):
#fuses HSPLL,NOMCLR,PUT,BROWNOUT,BORV43,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL5,CPUDIV1,VREGEN,CCP2B3
#use delay(clock=48000000)
#use rs232(baud=115200, xmit=TTL_TX, rcv=TTL_RX)
 
#define MaxRecords 255
 

Variables en RAM:

Código

GeSHi (csharp):
int8  timer1_overflows;
char  next_Interrupt_1;
char  next_Interrupt_2;
char  next_Interrupt_3;
int8  flagFirstEdge;
 
char   ChannelEdge[MaxRecords];
int8   Overflows[MaxRecords];
int16  Timer[MaxRecords];
int8   Index;
 

Código de Inicialización del sistema:

Código

GeSHi (csharp):
void limpia_data_records(void){
 
   for(Index=0;Index<MaxRecords;Index++){
      ChannelEdge[Index] = 0x00;
      Overflows[Index]   = 0x00;
      Timer[Index]       = 0x00;
   }
   Index=0;
}
 
void exec_COMMAND_START(void){
 
   limpia_data_records();
   flagFirstEdge = 0x00;
   ext_int_edge(0,H_TO_L); next_Interrupt_1='L';
   ext_int_edge(1,H_TO_L); next_Interrupt_2='L';
   ext_int_edge(2,H_TO_L); next_Interrupt_3='L';
   if( !input(PIN_B0) ){ ext_int_edge(0,L_TO_H); next_Interrupt_1='H'; }
   if( !input(PIN_B1) ){ ext_int_edge(1,L_TO_H); next_Interrupt_2='H'; }
   if( !input(PIN_B2) ){ ext_int_edge(2,L_TO_H); next_Interrupt_3='H'; }
   enable_interrupts(int_ext);
   enable_interrupts(int_ext1);
   enable_interrupts(int_ext2);
   enable_interrupts(int_timer1);
 
   printf("<%c,%c,%c,%c>\r\n",COMMAND_ACK,next_Interrupt_1,next_Interrupt_2,next_Interrupt_3);
}
 

Y las interrupciones para la Captura de Datos:

Código

GeSHi (csharp):
// Base de Tiempos //////////////////////////////////////////////////
#int_timer1
void timer1_handler(void){
 
   ++timer1_overflows;         // One Tick: 0.0833 uS, One Overflow: 5,461333 mS
 
}
 
// Canal 1 : RB0 ////////////////////////////////////////////////////
#int_ext
void channel_1_handler(void){
 
   if(flagFirstEdge==0x00){
      flagFirstEdge=0x01;
      timer1_overflows=0x00;
      set_timer1(0);
   }
 
   ChannelEdge[Index] = '1' + next_Interrupt_1;
   Overflows[Index]   = timer1_overflows;
   Timer[Index]       = get_timer1();
   ++Index;
 
   if(next_Interrupt_1=='H'){
      ext_int_edge(0,H_TO_L);
      next_Interrupt_1='L';
   }
   else{
     ext_int_edge(0,L_TO_H);
     next_Interrupt_1='H';
   }
 
}
 
// Canal 2 : RB1 ////////////////////////////////////////////////////
#int_ext1
void channel_2_handler(void){
 
   if(flagFirstEdge==0x00){
      flagFirstEdge=0x01;
      timer1_overflows=0x00;
      set_timer1(0);
   }
 
   ChannelEdge[Index] = '2' + next_Interrupt_2;
   Overflows[Index]   = timer1_overflows;
   Timer[Index]       = get_timer1();
   ++Index;
 
   if(next_Interrupt_2=='H'){
      ext_int_edge(1,H_TO_L);
      next_Interrupt_2='L';
   }
   else{
     ext_int_edge(1,L_TO_H);
     next_Interrupt_2='H';
   }
}
 
// Canal 3 : RB2 ////////////////////////////////////////////////////
#int_ext2
void channel_3_handler(void){
 
   if(flagFirstEdge==0x00){
      flagFirstEdge =0x01;
      timer1_overflows=0x00;
      set_timer1(0);
   }
 
   ChannelEdge[Index] = '3' + next_Interrupt_3;
   Overflows[Index]   = timer1_overflows;
   Timer[Index]       = get_timer1();
   ++Index;
 
   if(next_Interrupt_3=='H'){
      ext_int_edge(2,H_TO_L);
      next_Interrupt_3='L';
   }
   else{
     ext_int_edge(2,L_TO_H);
     next_Interrupt_3='H';
   }
}
 

Como podéis ver el tratamiento en las tres interrupciones externas es absolutamente idéntico. Y en cualquiera de ellas se controla únicamente si es el primero en llegar y se inicializa Timer1 en lo que corresponde mediante el código:

Código

GeSHi (csharp):
   if(flagFirstEdge==0x00){
      flagFirstEdge=0x01;
      timer1_overflows=0x00;
      set_timer1(0);
   }
 

Conclusiones y pregunta

Aquí tenéis un fichero de texto con un volcado completo de datos leídos.

Las primeras líneas son:
<D,  0,3,L,125,    6>             
<D,  1,1,L,  0,  339>             
<D,  2,1,H,  0, 2396>             
<D,  3,1,L,  0, 4444>             
<D,  4,1,H,  0, 6500>             
...

"Teóricamente" debería andar todo bien, y tal como se ve en la datos recogidos (las pruebas las he hecho con un dispositivo emisor de los trenes de pulsos conocido y sé que los tiempos recibidos son compatibles al 100% con lo esperado). Tengo perfectamente el canal, el tipo de flanco y el tiempo de llegada de cada uno de los flancos .... menos el primero. 

<D,  0,3,L,125,    6>             

El primero se recoge en el canal 3, #int_ext2 como debe ser, y por lo tanto el trocito de código que controla el flag flagFirstEdge se ejecuta en él, timer1_overflows y el timer1 se ponen a cero e inmediantamente se guardan donde se debe ... de echo el valor del timer1 de esa primer línea parece ser también correcto ya que 6 es lo esperado que tardaría en recogerse tras ejecutar el propio código de dentro de la interrupción.

Pero lo que no es posible creerse que los overflows sean 125. Simplemente no es posible.

Si se ejecuta timer1_overflows=0x00; y tres lineas mas abajo se ejecuta    Overflows[Index]   = timer1_overflows; no es posible que se recoja 125 en lugar de 0x00. Y Index no ha podido cambiar .... uffff

Lo dicho estoy desconcertado con este único "bug" y no se a que es debido.

Y quiero saberlo.

¿Se os ocurre algo? 

[Nocturno]

Don Diego, llevo un rato mirando y no encuentro el bug. Pienso que por alguna razón no está entrando en el bloque de código de inicialización determinado por flagFirstEdge=0 pero no veo cuál es esa razón.

No obstante, hay algo en tu programa que a mí particularmente no me gusta hacer, y no sé si tendría algo que ver. Has puesto un printf justo detrás de activar las interrupciones externas y del timer.
Como el printf es un proceso lento, que ejecuta mucho código y luego envía la información al puerto serie, quizás haga algo dentro que provoque ese efecto perverso que estás detectando con 125 overflowses.

En fin, seguro que tocando aquí y allá darás con la tecla y será una tontería, como suele ocurrir con estas cosas.

Por cierto, te digo otro truquito que yo he usado a veces y ahorra un montón de ciclos de reloj: el flanco (L o H) por el que salta una interrupción está en un bit. Si pones ese bit a 0 o 1 es lo mismo que si haces ext_int_edge(0,L_TO_H); o ext_int_edge(0,H_TO_L);

Esto es lo que hago en mi minidimmer. Aquí tendrás que poner la dirección de memoria del byte y la posición del bit en cuestión. Este código es válido para un 12F683:
#bit  SENTIDO_INTERRUPCION = 0x01.6

y en la interrupción haces esto:
SENTIDO_INTERRUPCION = ~SENTIDO_INTERRUPCION; // cambiamos de flanco la int.

Te aseguro que se ahorran un montón de ciclos de reloj. Compila y verás la diferencia.

[RedPic]

 

Si ya me lo dijo mi agüela: Ten güenos amigos y verás que bien se vive. 

1º.- Lo del printf no me s'había ocurrido pero puedes tener mas razón c'un santo.
2º.- Lo del bit de flanco no solo me gusta sino que leyéndolo puedo quitarme de enmedio la variable next_Interrupt_x donde me guardo exactamente lo mismo.

Genial, Manolo, genial. (sobre todo si es verdad)

[RedPic]

 

Mi desconcierto no tiene límites, es infinito, imponderable por su tamaño, es monstruoso, total, absoluto.

Implementadas todas la sugerencias de M.Nocturno el único cambio notado es que en ludar de obtener un primer dato de la forma <D,0,3,L,125, 6>   lo obtengo como <D,0,3,L,65,6> o sea que he pasado de tener un vicecontador de overflows de 125 a uno de 65 ...

Los bits de flanco están definidos por su ubicación física en el mapeado del PIC:

Código

GeSHi (csharp):
#define INTCON2 0xFF1
 
#bit Edge1 = INTCON2.6
#bit Edge2 = INTCON2.5
#bit Edge3 = INTCON2.4
 

El printf está ahora antes que la habilitación de interrupciones:

Código

GeSHi (csharp):
void exec_COMMAND_START(void){
 
   char sEdge1='u',sEdge2='u',sEdge3='u';
 
   limpia_data_records();
   flagFirstEdge = 0x00;
   Edge1=0;
   Edge2=0;
   Edge3=0;
   if( !input(PIN_B0) ) Edge1=1;
   if( !input(PIN_B1) ) Edge2=1;
   if( !input(PIN_B2) ) Edge3=1;
 
   if(Edge1) sEdge1='H'; else sEdge1='L';
   if(Edge2) sEdge2='H'; else sEdge2='L';
   if(Edge3) sEdge3='H'; else sEdge3='L';
 
   printf("<%c,%c,%c,%c>\r\n",COMMAND_ACK,sEdge1,sEdge2,sEdge3);
 
   timer1_overflows=0x00;
   set_timer1(0);
   enable_interrupts(int_ext);
   enable_interrupts(int_ext1);
   enable_interrupts(int_ext2);
   enable_interrupts(int_timer1);
}
 

Y las interrupciones son tratadas de forma mucho mas concisa de la forma:

Código

GeSHi (csharp):
#int_ext2
void channel_3_handler(void){
 
   if(flagFirstEdge==0x00){
      flagFirstEdge =0x01;
      timer1_overflows=0x00;
      set_timer1(0);
   }
 
   ChannelEdge[Index] = 'E'+Edge3;
   Overflows[Index]   = timer1_overflows;
   Timer[Index]       = get_timer1();
   ++Index;
   ++Edge3;
}
 

Lo único que he cambiado de la propuesta original de M.Nocturno es que su SENTIDO_INTERRUPCION = ~SENTIDO_INTERRUPCION; lo he implementado como ++SENTIDO_INTERRUPCION ya que al ser un solo bit obtengo los mismo resultados, el de su conmutación de estado.

Por lo demás obtengo los mismos valores salvo el susodicho inicial y ... como la Scarlett O´Hara en Lo que el viento se llevó juro con el puño en alto bajo el inmenso roble con un cielo rojo sangre que tengo que enterarme de por qué pasa esto. Por mis niños que lo tengo que saber.

[Azicuetano]

A ver si tu desconcierto viene debido a un error de orden superior Don Diego.

Has visto los Data-Errata de ese micro?

http://www.microchip.com/wwwproducts/Devices.aspx?dDocName=en010300

Comentan algo de los Timers y me suena que hace tiempo leí algo de las interrupciones externas.

Ese micro tiene algunas erratas y es importante que las veas todas.

A ver si hay suerte por este camino (lo que te pasa es tan raro que es lo único que se me ocurre).


Un saludo desde Alicante.

[RedPic]

A ver si hay suerte por este camino (lo que te pasa es tan raro que es lo único que se me ocurre).

Echémosle un vistazo a las ^*Errata Picae Dolorem Cabezorum Genis. 

^* Errores en los PIC's que generan dolores de cabeza.

[Nocturno]

Don Diego, no nos has enseñado la rutina que utilizas para volcar el contenido de los arrays sobre la salida serie. Sé que haces algún cálculo allí dentro para obtener el flanco (L o H) y el canal (1, 2 o 3) a partir del array ChannelEdge.
No creo que esté ahí el problema pero, ¿lo miramos?

[RedPic]

Un rato más ... que hay cambios y tengo nuevos resultados. Voy a ver si me aclaro algo y os pongo alguna conclusión.

[RedPic]

20 Horas después de mi anterior post ya tengo las conclusiones. Un cúmulo de errores, desconocimientos, fallo sobre fallo y tiro por que me toca hacen que haya sido difícil sobre todo entender qué es lo que estaba pasando.

Pero ya está solucionado y clarificado. 

Paso a explicaros los porqueses de todo esto.

Errores:

1º.- El primer error fue el de la misma fuente de datos, el generador de pulsos largaba mas de los 255 flancos entre los tres canales por lo que los últimos sobre-escribían los primeros al desbordar el contador-índice de los Arrays de datos.

2º.- Como bien decía M.Nocturno el poner un printf después de habilitar las interrupciones falseaba los datos al ser el printf extremadamente lento.

3º.- Utilizar la técnica estándar de Array[Indice]=Valor es extremadamente costoso en términos de líneas programa ASM compiladas por el CCS, lo que unido a guardar cuatro valores de este tipo en cada interrupción eran muy largos-lentos y se perdían flancos entre tanto.
 
4º.- El intento de acumular los valores de Channel y Edge en un único valor a guardar hizo todo aún mas lento.

Soluciones:

1º.- Obviamente cambiar el tipo de entero de int8 a int16 del índice para poder acumular mas datos y elever al mismo tiempo subir en el array el número de muestras de 255 a 381, así nos aseguramos que no nos excedemos en el número de datos recogidos.

2º.- Mover o remover todos los procesos no fundamentales con el fin de que al iniciar la toma de datos no se ejecute absolutamente nada accesorio. Asimismo implemento el acceso directo a los registros de cambio de flanco para el disparo de las interrupciones. También se ordena la prioridad de las mismas con #priority y por si acaso (los errores del Timer1 en el 18F4550) he cambiado la base de tiempos del Timer1 al Timer3.

3º.- Para evitar el uso de los índices de un Array he creado una estructura con los cuatro valores, he creado una variable simple con esa estructura que es la que recojo en las interrupciones y después la muevo con un memcpy a su ubicación definitiva en la RAM. Este proceso es infinitamente mas rápido que guardar en el Array las variables una a una porque cada vez hay que recuperar la posición del índice mientras que con el memcpy solo se hace una vez para toda la estructura.

4º.- Con lo anterior este error queda obsoleto y los datos de Channel y Edge se guardan en "crudo" , sin tratar, y solo posteriormente se hará al enviarlos al PC.


Nuevo código Fuente:

Los Defines, Constantes y RAM queda así:

Código

GeSHi (csharp):
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// DEFINES y CONSTANTES
//
///////////////////////////////////////////////////////////////////////////////////////////////////
 
#define INTCON2 0xFF1
#bit Edge1 = INTCON2.6
#bit Edge2 = INTCON2.5
#bit Edge3 = INTCON2.4
 
struct tRecord{
 
   char  Channel;
   char  Edge;
   int8  Overflow;
   int16 Timer;
};
 
#define MaxRecords 381
 
///////////////////////////////////////////////////////////////////////////////////////////////////
//
// R A M
//
///////////////////////////////////////////////////////////////////////////////////////////////////
 
char   Command='\0';
 
int16  Index;
int8   timer3_overflows;
struct tRecord singleRecord;
struct tRecord Records[MaxRecords];
 

Y estas son las nuevas interrupciones:

Código

GeSHi (csharp):
// Base de Tiempos //////////////////////////////////////////////////
#int_timer3
void timer3_handler(void){
   ++timer3_overflows;         // One Tick: 0.0833 uS, One Overflow: 5,461333 mS
}
 
// Canal 1 : RB0 ////////////////////////////////////////////////////
#int_ext
void channel_1_handler(void){
 
   singleRecord.Overflow = timer3_overflows;
   singleRecord.Timer    = get_timer3();
   singleRecord.Edge     = Edge1;
   singleRecord.Channel  = '1';
   ++Edge1;
   memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
   ++Index;
}
 
// Canal 2 : RB1 ////////////////////////////////////////////////////
#int_ext1
void channel_2_handler(void){
 
   singleRecord.Overflow = timer3_overflows;
   singleRecord.Timer    = get_timer3();
   singleRecord.Edge     = Edge2;
   singleRecord.Channel  = '2';
   ++Edge2;
   memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
   ++Index;
 
}
 
// Canal 3 : RB2 ////////////////////////////////////////////////////
#int_ext2
void channel_3_handler(void){
 
   singleRecord.Overflow = timer3_overflows;
   singleRecord.Timer    = get_timer3();
   singleRecord.Edge     = Edge3;
   singleRecord.Channel  = '3';
   ++Edge3;
   memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
   ++Index;
}
 

Y por último el nuevo DUMP de datos se realiza de esta forma:

Código

GeSHi (csharp):
void dump_data_record(int16 nrecord){
 
   int8 dispOverflow;
   
   dispOverflow=Records[nrecord].Overflow-Records[0].Overflow;
 
   printf("<%c,%3Lu,%c,%c,%3u,%5Lu>\r\n",COMMAND_DUMP,nrecord,Records[nrecord].Channel,'0'+Records[nrecord].Edge,dispOverflow,Records[nrecord].Timer);
}
 
void exec_COMMAND_DUMP(void){
 
   int16 i;
 
    for(i=0;i<Index;i++){ // Direct
   // for(i=Index;i<255;--i){ // Reverse
 
      // Corrección de Errores de Recogida de Datos ...
 
      if(i>0){ // Si hay dato anterior
         if(Records[i].Timer<100 && (Records[i].Overflow==Records[i-1].Overflow)){ // Si la recogida del Timer es menor que 100 y ..
            Records[i].Overflow +=1;                                               // el Overflow es igual al anterior el overflow es uno más.
         }
      }
 
      dump_data_record(i);
   }
   printf("Overflows Offset %3u\r\n",Records[0].Overflow);
}
 

Fijaos que en este último trozo de código hay una pequeña corrección para cuando el valor del Timer recogido es pequeño ya que entonces es seguro que la interrupción del Overflow llega tarde y por lo tanto se recoge el valor de overflows anterior.

Resultados:

Y por fin los resultados son completos, correctos y satisfactorios. 

Os pongo el inicio y el final de una recogida de datos:

<U,L,L,L>                           
<D,  0,3,0,  0,57774>               
<D,  1,1,0,  0,58110>               
<D,  2,1,1,  0,60166>               
<D,  3,1,0,  0,62214>               
<D,  4,1,1,  0,64271>               
<D,  5,1,0,  1,  783>               
<D,  6,1,1,  1, 2839>               
<D,  7,1,0,  1, 4887>               
<D,  8,1,1,  1, 6944>               
<D,  9,1,0,  1, 8992>               
<D, 10,1,1,  1,11049>               
<D, 11,1,0,  1,13097>               
<D, 12,1,1,  1,15153>               
...
...
...
<D,242,1,1,  7,26193>               
<D,243,1,0,  7,28241>               
<D,244,1,1,  7,30297>               
<D,245,1,0,  7,32345>               
<D,246,1,1,  7,34402>               
<D,247,1,0,  7,36450>               
<D,248,1,1,  7,38507>               
<D,249,1,0,  7,40555>               
<D,250,1,1,  7,42611>               
<D,251,1,0,  7,44659>               
<D,252,1,1,  7,46716>               
<D,253,1,0,  7,48764>               
<D,254,1,1,  7,50820>               
<D,255,1,0,  7,52868>               
<D,256,1,1,  7,54925>               
<D,257,3,1,  7,56725>               
Overflows Offset 208                 
                                     
Así que esta primera fase la doy por conclusa. 

[Nocturno]

Eres un crack. Me alegro que lo hayas resuelto, y me alegro que hayas aplicado de forma tan elegante el truco del memcpy, porque resulta sumamente interesante.

[RedPic]

Gracias Manolo. Fíjate que estuve tentado de escribir el interior de las interrupciones en ASM pero después decidí intentar aún algo en C y tiré de las funciones de manejo directo de la memoria.

Este es el código ASM compilado por el CCS con el manejo de Arrays e índice en una interrupción anteriormente:

Código

GeSHi (asm):
.................... // Canal 1 : RB0 ////////////////////////////////////////////////////
0186:  BCF    FA1.1
0188:  GOTO   0088
.................... #int_ext
.................... void channel_1_handler(void){
....................
....................    Overflows[Index]   = timer3_overflows;
018C:  CLRF   03
018E:  MOVLB  4
0190:  MOVF   x16,W
0192:  ADDLW  19
0194:  MOVWF  FE9
0196:  MOVLW  01
0198:  ADDWFC 03,W
019A:  MOVWF  FEA
019C:  MOVFF  19,FEF
....................    Timer[Index]       = get_timer3();
01A0:  BCF    FD8.0
01A2:  RLCF   x16,W
01A4:  MOVWF  02
01A6:  CLRF   03
01A8:  RLCF   03,F
01AA:  MOVF   02,W
01AC:  ADDLW  18
01AE:  MOVWF  FE9
01B0:  MOVLW  02
01B2:  ADDWFC 03,W
01B4:  MOVWF  FEA
01B6:  MOVF   FB2,W
01B8:  MOVFF  FB3,03
01BC:  MOVWF  FEF
01BE:  MOVFF  03,FEC
01C2:  MOVF   FED,F
....................    ChannelEdge[Index] = 'A'+Edge1;
01C4:  CLRF   03
01C6:  MOVF   x16,W
01C8:  ADDLW  1A
01CA:  MOVWF  FE9
01CC:  MOVLW  00
01CE:  ADDWFC 03,W
01D0:  MOVWF  FEA
01D2:  MOVLW  00
01D4:  BTFSC  FF1.6
01D6:  MOVLW  01
01D8:  ADDLW  41
01DA:  MOVWF  FEF
....................    ++Index;
01DC:  INCF   x16,F
....................    ++Edge1;
01DE:  BTG    FF1.6
.................... }
 

Y este los mismo con el memcpy() :

Código

GeSHi (asm):
.................... // Canal 1 : RB0 ////////////////////////////////////////////////////
0186:  BCF    FA1.1
0188:  GOTO   0088
.................... #int_ext
.................... void channel_1_handler(void){
....................
....................    singleRecord.Overflow = timer3_overflows;
*
01AE:  MOVFF  1C,1F
....................    singleRecord.Timer    = get_timer3();
01B2:  MOVF   FB2,W
01B4:  MOVFF  FB3,03
01B8:  MOVWF  20
01BA:  MOVFF  03,21
....................    singleRecord.Edge     = Edge1;
01BE:  CLRF   1E
01C0:  BTFSC  FF1.6
01C2:  INCF   1E,F
....................    singleRecord.Channel  = '1';
01C4:  MOVLW  31
01C6:  MOVWF  1D
....................    ++Edge1;
01C8:  BTG    FF1.6
....................    memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
01CA:  MOVFF  1B,7B7
01CE:  MOVFF  1A,7B6
01D2:  MOVLB  7
01D4:  CLRF   xB9
01D6:  MOVLW  05
01D8:  MOVWF  xB8
01DA:  MOVLB  0
01DC:  RCALL  018C
01DE:  MOVFF  02,03
01E2:  MOVF   01,W
01E4:  ADDLW  22
01E6:  MOVLB  7
01E8:  MOVWF  xAC
01EA:  MOVLW  00
01EC:  ADDWFC 02,W
01EE:  MOVWF  xAD
01F0:  MOVWF  FEA
01F2:  MOVFF  7AC,FE9
01F6:  CLRF   FE2
01F8:  MOVLW  1D
01FA:  MOVWF  FE1
01FC:  MOVLW  05
01FE:  MOVWF  01
0200:  MOVFF  FE6,FEE
0204:  DECFSZ 01,F
0206:  BRA    0200
....................    ++Index;
0208:  INCF   1A,F
020A:  BTFSC  FD8.2
020C:  INCF   1B,F
.................... }
 

[Nocturno]

Te tiro otra sugerencia, por si te apetece recogerla.
1.- Guarda en tres variables el estado inicial de los tres pines de entrada, o sea, el que te permitirá saber qué flanco será el siguiente en llegar y levantar la interrupción.
2.- Deja de almacenar el flanco actual en cada interrupción. Se simplifica tu estructura en un byte (20% de la misma) y el código compilado en 4 instrucciones.
3.- A la hora de hacer el dump reconstruyes a partir del flanco inicial el resto de los flancos cambiándolos cada vez que se haya leído una captura en un pin.

[RedPic]

Hummm ... imagino que jugando con un único puntero e incrementándolo en sizeof(singleRecord) y asignando valores uno a uno se podría hacer aún mas corto y eficaz.

[jeremylf]

Wow.

Cuanta precicion, eso me gusta. Pero, el echo de que el pic corra a 0.08333....... us te quita algo de precicion creo yo, y es una pena y algo que siempre tendre como un bichito en la cabeza  No es algo como corriendo al pic a 4 o 20 mhz donde si es exacto.

Habria que probar con los pic32 que corren a 80mhz = 0.0125us EXACTO! 

Aun asi, te quedo de lujo!
Un saludo.

[RedPic]

Te tiro otra sugerencia, por si te apetece recogerla.
1.- Guarda en tres variables el estado inicial de los tres pines de entrada, o sea, el que te permitirá saber qué flanco será el siguiente en llegar y levantar la interrupción.
2.- Deja de almacenar el flanco actual en cada interrupción. Se simplifica tu estructura en un byte (20% de la misma) y el código compilado en 4 instrucciones.
3.- A la hora de hacer el dump reconstruyes a partir del flanco inicial el resto de los flancos cambiándolos cada vez que se haya leído una captura en un pin.

Implementado con éxito tu indicación.   

Así en la RAM me defino tres variables int1

Código

GeSHi (csharp):
int1   iEdge1, iEdge2, iEdge3;
 

Que inicializo con los valores contrarios léidos con input por cada canal

Código

GeSHi (csharp):
   ext_int_edge(0,H_TO_L);
   ext_int_edge(1,H_TO_L);
   ext_int_edge(2,H_TO_L);
   if( !input(PIN_B0) ){ ext_int_edge(0,L_TO_H); }
   if( !input(PIN_B1) ){ ext_int_edge(1,L_TO_H); }
   if( !input(PIN_B2) ){ ext_int_edge(2,L_TO_H); }
 
   iEdge1=Edge1;
   iEdge2=Edge2;
   iEdge3=Edge3;
 

Y en las interrupciones #int_ext, #int_ext1 e #int_ext2 dejo de guardar este dato centrándome solo en el canal y los datos de Timer

Código

GeSHi (csharp):
#int_ext
void channel_1_handler(void){
 
   singleRecord.Overflow = timer3_overflows;
   singleRecord.Timer    = get_timer3();
   singleRecord.Channel  = '1';
   ++Edge1;
   memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
   ++Index;
}
...
 

Pero al hacerp el DUMP lo reconstruyo en función del estado inicial y conmutando sucesivamente de forma independiente por cada canal antes de utilizar el printf

Código

GeSHi (csharp):
   // Computa Edge en función de iEdgex
   sEdge='u';
   switch(Records[nrecord].Channel){
      case '1': sEdge='0'+iEdge1; ++iEdge1; break;
      case '2': sEdge='0'+iEdge2; ++iEdge2; break;
      case '3': sEdge='0'+iEdge3; ++iEdge3; break;
   }
 

Con esto y al compilar una interrupción queda reducida a

Código

GeSHi (asm):
.................... // Canal 1 : RB0 ////////////////////////////////////////////////////
.................... #int_ext
.................... void channel_1_handler(void){
....................
018C:  MOVFF  1C,1E ....................    singleRecord.Overflow = timer3_overflows;
0190:  MOVF   FB2,W ....................    singleRecord.Timer    = get_timer3();
0192:  MOVFF  FB3,03
0196:  MOVWF  1F
0198:  MOVFF  03,20 ....................    singleRecord.Channel  = '1';
019C:  MOVLW  31
019E:  MOVWF  1D
01A0:  BTG    FF1.6 ....................    ++Edge1;
01A2:  RLCF   1A,W  ....................    memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
01A4:  MOVWF  02
01A6:  RLCF   1B,W
01A8:  MOVWF  03
01AA:  RLCF   02,F
01AC:  RLCF   03,F
01AE:  MOVLW  FC
01B0:  ANDWF  02,F
01B2:  MOVF   02,W
01B4:  ADDLW  21
01B6:  MOVLB  6
01B8:  MOVWF  x4F
01BA:  MOVLW  00
01BC:  ADDWFC 03,W
01BE:  MOVWF  x50
01C0:  MOVWF  FEA
01C2:  MOVFF  64F,FE9
01C6:  CLRF   FE2
01C8:  MOVLW  1D
01CA:  MOVWF  FE1
01CC:  MOVLW  04
01CE:  MOVWF  01
01D0:  MOVFF  FE6,FEE
01D4:  DECFSZ 01,F
01D6:  BRA    01D0
01D8:  INCF   1A,F ....................    ++Index;
01DA:  BTFSC  FD8.2
01DC:  INCF   1B,F
.................... }
 

Y ahora la pregunta del millón de un profundo desconocedor del ASM ... ¿cada instrucción ocupa 4 ciclos de reloj? o ¿hay instrucciones de mas y/o menos ciclos?. Lo digo para calcular exactamente cuanto ocupa en tiempo la ejecución de la interrupción.

Si la respuesta a la primera pregunta es SI y NO a la segunda y contando cuento 36 instrucciones a 4 ciclos de reloj cada una hacen un total de ciclos de 144 ciclos y con el PIC corriendo a 48 Mhz con cada ciclo a 1/48000000 resulta que la interrupción se ejecuta en 0,000003 (en segundos) o sea 3 microsegundos.

¿Yes OR Not Yes? 

[Nocturno]

Diego, mira la tabla 26-2 de la Datasheet: PIC18FXXXX INSTRUCTION SET

Hay una columna al lado de cada instrucción que dice "Cycles".

De todas formas, para medir el tiempo que toma la interrupción te recomiendo otro método. Carga tu programa en MPLAB, le das al debugger paso a paso y con la ventana Stopwatch tienes el tiempo exacto tanto en ciclos de reloj como en microsegundos (si has configurado bien la frecuencia de trabajo).

[RedPic]

Ya. My gozo in the pozo. 

[Nocturno]

¿Qué t'ha pasao?

[RedPic]

Nada, nada ... que el cálculo de 4 ciclos por cuarto-y-mitad de instrucción es una cagada. Me pongo a contar ciclos por tipo de instrucción según tabla y sumo de verdad (el MPLAB no es mi fuerte) ... 

[RedPic]

Pues salvo error u omisión mi cálculo anterior no es tan descaminado como parecíame al principio ...

He colocado a la izquierda de cada instrucción el número de ciclos de intrucciones que consume ...

Código

GeSHi (csharp):
 2 018C:  MOVFF  1C,1E ....................    singleRecord.Overflow = timer3_overflows;
 1 0190:  MOVF   FB2,W ....................    singleRecord.Timer    = get_timer3();
 2 0192:  MOVFF  FB3,03
 1 0196:  MOVWF  1F
 2 0198:  MOVFF  03,20 ....................    singleRecord.Channel  = '1';
 1 019C:  MOVLW  31
 1 019E:  MOVWF  1D
 1 01A0:  BTG    FF1.6 ....................    ++Edge1;
 1 01A2:  RLCF   1A,W  ....................    memcpy(&Records[Index],&singleRecord,sizeof(singleRecord));
 1 01A4:  MOVWF  02
 1 01A6:  RLCF   1B,W
 1 01A8:  MOVWF  03
 1 01AA:  RLCF   02,F
 1 01AC:  RLCF   03,F
 1 01AE:  MOVLW  FC
 1 01B0:  ANDWF  02,F
 1 01B2:  MOVF   02,W
 1 01B4:  ADDLW  21
 1 01B6:  MOVLB  6
 1 01B8:  MOVWF  x4F
 1 01BA:  MOVLW  00
 1 01BC:  ADDWFC 03,W
 1 01BE:  MOVWF  x50
 1 01C0:  MOVWF  FEA
 2 01C2:  MOVFF  64F,FE9
 1 01C6:  CLRF   FE2
 1 01C8:  MOVLW  1D
 1 01CA:  MOVWF  FE1
 1 01CC:  MOVLW  04
 1 01CE:  MOVWF  01
 2 01D0:  MOVFF  FE6,FEE
 3 01D4:  DECFSZ 01,F
 2 01D6:  BRA    01D0
 1 01D8:  INCF   1A,F ....................    ++Index;
 3 01DA:  BTFSC  FD8.2
 1 01DC:  INCF   1B,F
 

Que sumadas hacen un total de 46 ciclos de intrucción, y como cada uno de ellos consume 4 ciclos de reloj tenemos un total de 46 * 4 = 184 ciclos de reloj. Sólo 40 mas que en el calculo anterior.

Hay dos instrucciones, DECFSZ y  BTFSC, que el Datasheet dice 1 ciclo (2 ó 3) y como no indica cuando ocupa cuantos ciclos he puesto que siempre ocupa 3.

Así que 184 * 1 / 48000000 = 3,8333 microsegundos. Casi 4 microsegundos que no está nada mal (para los tiempos que estoy sensando que son del orden de los 250 microsegundos) 

Un poné.

Muchas gracias manuelo.