Analizador lógico de 3 Canales monitorizado en el PC

[Nocturno]

Dudo que te sirva de ayuda mi comentario, porque veo que tienes el tema bastante controlado y seguramente lo que te diré será producto de mi espesura, pero por si acaso.

Según veo, la variable que determina si el próximo pulso debe ser de bajada o de subida es fedge. Por lo que veo, dicha variable no cambia a un estado fijo en cada parte del if (fedge==0), sino que posteriormente haces un ++fedge;

Deduzco por tanto que fedge es de tipo boolean y con esa operación vas invirtiéndola.

Sin embargo, yo me aseguraría poniendo:

Código: CSS

1. if(fedge==0){
2.       ext_int_edge(0,L_TO_H);
3.       TimesDownI[uTimeDown]=n;
4.       TimesDownT[uTimeDown]=t;
5.       ++uTimeDown;
6.       fedge=1;
7.    }
8.    else
9.    {
10.       ext_int_edge(0,H_TO_L);
11.       TimesUpI[uTimeUp]=n;
12.       TimesUpT[uTimeUp]=t;
13.       ++uTimeUp;
14.       fedge=0;
15.    }

¿Cómo lo ves?

[RedPic]

Manolo, Efectivamente fedge es int1, y como tú dices estaba antes .... lo quité y lo puse con ++fedge con los mismos resultados. Lo hice así en un intento de acortar el código dentro del manejo de la interrupción ... antes tambien tenia las tablas como multidimensionales TimesUp[n][m] pero las abría en dos distintas y el código volvio a decrecer ...

Creo que es un problema de tiempos .... creo que es un problema de tiempos .... creo que es un problema de tiempos .... pero ... ¿donde? ... ¿donde? ... ¿donde? ...

[Nocturno]

Hombre si un pulso es extra-corto, a tu soft sólo le dará tiempo de ver un flanco (el de bajada o el de subida), pero no el otro.

Quizás, en el tiempo que el micro no está haciendo nada, en el bucle del main, deberías estar permanentemente controlando que la señal está al nivel que se supone que debería estar. O sea, si estás esperando un pulso de subida debería estar a 0, y si lo esperas de bajada debería estar a 1.

Si algo no encaja, podrías enviar un código de error.

[RedPic]

Bicheando por el Foro he dado con esto del maestro, y sin embargo amigo, J1M : Módulo USB del 18Fx550 usado para sus inventos USBianos ...

Código: CSS

1. ...
2. Para vuestro caso que es de 4Mhz tendriais:
3. #fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN
4. #use delay(clock=48000000)
5. ...
6.  

Me he ido a la página 32 del datasheet del 18F4550 y ....



Entonces la pregunta sería ... ¿me sirve esto para poner mi 4550 a tó lo que dé? ....

Si me ayudais a encontrar los fuses correctos ... ¿podemos hacer andar el 4550 a 48Mhz con mi critsal de 20Mhz?

¿Es a esto a lo que se refería el maestro Sisco?

          

[Nocturno]

Lo máximo que corre es a 48MHz con cristal de 12MHz y PLLx4.
Pero no te confundas, eso son 12MIPS, porque cada instrucción se come cuatro ciclos de reloj.

[RedPic]

Lo máximo que corre es a 48MHz con cristal de 12MHz y PLLx4.
Pero no te confundas, eso son 12MIPS, porque cada instrucción se come cuatro ciclos de reloj.

Entonces 48 MHZ -> 12 MIPS y como yo ahora tengo 20 MHZ -> 5 MIPS podemos 12 MIPS - 5 MIPS = + 7 MIPS lo que significa que obtengo una ganancia neta de + 7 MIPS, cuasi triplicando mi actual velocidad de proceso ....

¿Los TIMER'S van en consonancia? quiero decir si con 20MHZ a pelo tengo un tick de Timer1 de 0.2 uS ¿debo esperar con los 12MHZ Peeleleados un tick de Timer1 de 0.083 uS?

¿eh?

[RedPic]

Un post breve pero importante antes de la traca final con banda de música, bar ambigú y cantos regionales que va a significar mi siguiente post con la finalización, conclusión, acabado, peinado y puesta en carga de este larguísimo e inacabable proyecto. 

Teoria y práctica para la implementación de un protocolo cutre, chapucero y venido a menos, entre un Pic 18F4550, programado en CSS C, sobre tarjeta de desarrollo Edupic con un cristal de 20MHZ y un PC AMD Semprom +2600 con 1 GByte de RAM, dotado operativamente de Windows XP Professional Service Pack II, sobre el que se ejecuta un programa aplicativo desarrollado en Boralnd Delphi 6.0 Enterprise Update Pack 2, mediante el VCL ApdComPort de la librería TpaPro (TurboPower Async Professional Package en Sourceforgue.net) mediante interface RS-232-C estándar en ambos extremos.

ja, ja, ja      ... con el título sólo mas de uno se hace una tesis doctoral .... ja, ja, ja     

1º Lista de comandos PC -> PIC

   COMMAND_RESET    = 'R';
   COMMAND_FIRMWARE = 'W';
   COMMAND_DATA     = 'X';
   COMMAND_CONFIG   = 'C';
   COMMAND_CONFIG1  = '1';
   COMMAND_CONFIG2  = '2';
   COMMAND_CONFIG3  = '3';

2º Comando de ACK (Acknowledge Receipt of a Packet) PIC -> PC

char const RESPONSE_ACK          = '^';

printf("^\r\n");

3º Estructura de transmisión datos PIC -> PC

CI (Carácter de Inicio) = '{'
CF (Carácer de Finalizacion) = '}'

Estructura de envío : n * (CI + m * (data) + CF + '\r\n') + ACK

4º Estructura de datos de configuración, 1 byte:

Codificacion en Delphi:

     c.Compreso := 0;
     if c.Active  then c.Compreso := c.Compreso + 128;
     if c.Raising then c.Compreso := c.Compreso +  64;
     if c.Falling then c.Compreso := c.Compreso +  32;
     if c.Trigger then c.Compreso := c.Compreso +  16;
     if c.Invert  then c.Compreso := c.Compreso +   8;

Decodificacion en CSS C por Bit

   // Habilito Canal 1
   if(bit_test(C1_SETTINGS,7)==1){
      enable_interrupts(int_ext);
   }
   ...
   // Configuro Channel1 Flanco inicial
   if(bit_test(C1_SETTINGS,7)==1){
     if(bit_test(C1_SETTINGS,5)==1){
        fedge1=0;
        ext_int_edge(0,H_TO_L);
     }
     if(bit_test(C1_SETTINGS,6)==1){
        fedge1=1;
        ext_int_edge(0,L_TO_H);
     }
   }

y 5º Estructura de datos de muestreo

CI + NumPulso + Canal + nRTCC raise + Timer raise + nRTCC fall + Timer fall + CF + "\r\n"

Emisión en CSS C:

   for(i=0;i<NMUESTRAS;i++){
      printf("{ %3u %1u %5lu %5lu %1u %5lu %5lu }\r\n",i+1,tUpC[ i ],tUpI[ i ],tUpT[ i ],tDownC[ i ],tDownI[ i ],tDownT[ i ]);
   }
   delay_ms(10);
   ack_trans();

===========================================================

E j e m p l o s


Ejemplo: Orden de "envíame" la versión del firmware actual.

Al recibir el PIC el comando 'W' envía el string "{1.2.0}[13][10]^\r\n"

Ejemplo : Conversación completa PC <-> PIC comentada

Transmit: W     Receive: {1.2.0}[13][10]^[13][10]  Pregunta firmare y recibe firmware

Transmit: C     Receive: { 177 209 209 }[13][10]^[13][10] Pregunta configuracion y recibe settings de los tres canales

Transmit: 1     Receive: ^[13][10] Envia "preparate para recibir configuracion canal 1" recibe ACK

Transmit: [177] Receive: ^[13][10] Envia "configuracion canal 1" recibe ACK

Transmit: 2     Receive: ^[13][10] Envia "preparate para recibir configuracion canal 2" recibe ACK

Transmit: [177] Receive: ^[13][10] Envia "configuracion canal 2" recibe ACK

Transmit: 3     Receive: ^[13][10] Envia "preparate para recibir configuracion canal 2" recibe ACK

Transmit: [177] Receive: ^[13][10] Envia "configuracion canal 3" recibe ACK

Transmit: R     Receive: ^[13][10] Envia "reseteate, limpia muestreos anteriores y reconfigurate" recibe ACK

Transmit: C     Receive: { 177 177 177 }[13][10]^[13][10] Envia "dame configuraciones" recibe configuraciones de los tres canales y ACK

Transmit: X     

Receive: {   1 1    11 32930 1     0     8 }[13][10] Envía "dame muestreos" y recibe tabla de datos
            {   2 1    46 52262 1    37 43339 }[13][10]
            {   3 0     0     0 0     0     0 }[13][10]
            {   4 0     0     0 0     0     0 }[13][10]
            {   5 0     0     0 0     0     0 }[13][10]
                 ...
            {  65 0     0     0 0     0     0 }[13][10]
            ^[13][10]



Nota 1: Todo el código completo en el post final de este proyecto.

Nota 2: Todo este control desarrollado para comunicar con un Soft específico que dibuje los pulsos en pantalla está disponible en el Firmware del 18F4550 para ser accedido numéricamente desde un simple terminal serie (Siow, Hyperterminal ... etc) estilo Telnet.

[RedPic]

Lo prometido es deuda. Aquí está el final de este proyecto.

¡¡¡ Que suenen las trompetas !!!! ¡¡¡¡ Que repiquen las campanas !!!!

                         

Una imagen vale mas que mil palabras




Le he conectado un Lector de Tarjetas de Proximidad marca Ápice utilizando el protocolo OMROM C&D; cuya transmisión de datos la efectúa con tres señales, Clock (CK), Data (DT) y Card Present (CP).

Ésta última señal de CP se activa antes de comenzar la transmisión y se desactiva la última tras haber concluído con la misma.

La señal de reloj CK es una serie de pulsos síncronos con un periodo de 500 uS y un Duty Cicle del 50%.

Cada señal de CK muestra el valor de un bit de Datos en DT.

La transmisión de datos se inicia y se finaliza con 8 bits "cero".

La transmisión de los datos relativos al código grabado en la tarjeta se compone de tantos grupos de 4 bits (nibble LSB) mas paridad par como dígitos tenga éste. En el caso concreto de esta trasmisión monitorizada por la Sonda Lógica es el número 79127.

He utilizado este ejemplo en concreto porque profesionalmente soy el padre del firmware del lector que realiza la transmisión, y por lo tanto conozco perfectamente el tipo de señales que iba a recibir en la sonda, con lo que el evaluar si funciona correctamente era mucho mas fácil. A esto le he llamado la "fase de calibración" cuyos resultados podéis ver en la imagen anterior.

El programa CSS C que implementa la sonda es:

Código: CSS

1. // RR Logical Analyzer v.1.2.2d
2.  
3. #include <18f4550.h>
4. #fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN
5. #use delay(clock=20000000)
6. #use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)
7.  
8. int  const NMUESTRAS=192;
9.  
10. char const SOFT_COMMAND_RESET    = 'r';
11. char const SOFT_COMMAND_FIRMWARE = 'w';
12. char const SOFT_COMMAND_DATA     = 'x';
13. char const SOFT_COMMAND_CONFIG   = 'c';
14. char const SOFT_COMMAND_EEPROM   = 'e';
15.  
16. char const HARD_COMMAND_RESET    = 'R';
17. char const HARD_COMMAND_FIRMWARE = 'W';
18. char const HARD_COMMAND_DATA     = 'X';
19. char const HARD_COMMAND_CONFIG   = 'C';
20. char const HARD_COMMAND_CONFIG1  = '1';
21. char const HARD_COMMAND_CONFIG2  = '2';
22. char const HARD_COMMAND_CONFIG3  = '3';
23. char const RESPONSE_ACK          = '^';
24.  
25. int  const DIR_C1_SETTINGS       =  0;
26. int  const DIR_C2_SETTINGS       =  1;
27. int  const DIR_C3_SETTINGS       =  2;
28.  
29. // Variables en RAM /////////////////////////////////////////////////
30.  
31. char Version[]="1.2.2d\0";
32. char CharRcv=0;
33. char Command=0;
34.  
35. int  i=0x00;
36. int  uTimeUp=0;
37. int  uTimeDown=0;
38. int  nTintext=0;
39. int  tUpC[NMUESTRAS];
40. long tUpT[NMUESTRAS];
41. long tUpI[NMUESTRAS];
42. int  tDownC[NMUESTRAS];
43. long tDownT[NMUESTRAS];
44. long tDownI[NMUESTRAS];
45. long nTimer1Overflow;
46. int1 fedge1=0;
47. int1 fedge2=0;
48. int1 fedge3=0;
49. int1 flag_recibe_config1=0;
50. int1 flag_recibe_config2=0;
51. int1 flag_recibe_config3=0;
52.  
53. // Settings x CANAL /////////////////////////////////////////////////
54.  
55. int  C1_Settings= 0;
56. int1 C1_Active  = 0;
57. int1 C1_Raising = 0;
58. int1 C1_Falling = 0;
59. int1 C1_Trigger = 0;
60. int1 C1_Invert  = 0;
61.  
62. int  C2_Settings= 0;
63. int1 C2_Active  = 0;
64. int1 C2_Raising = 0;
65. int1 C2_Falling = 0;
66. int1 C2_Trigger = 0;
67. int1 C2_Invert  = 0;
68.  
69. int  C3_Settings= 0;
70. int1 C3_Active  = 0;
71. int1 C3_Raising = 0;
72. int1 C3_Falling = 0;
73. int1 C3_Trigger = 0;
74. int1 C3_Invert  = 0;
75.  
76. // Definicion de funciones //////////////////////////////////////////
77.  
78. void menu_trans(void);
79. void friendly_eeprom_trans(void);
80. void friendly_firmware_trans(void);
81. void hardy_firmware_trans(void);
82. void friendly_data_trans(void);
83. void hardy_data_trans(void);
84. void friendly_config_trans(void);
85. void hardy_config_trans(void);
86. void on_reset(int1 verbose);
87. void ack_trans(void);
88. void set_channel1(void);
89. void set_channel2(void);
90. void set_channel3(void);
91. void config_channels(int1 verbose);
92.  
93. #int_rda
94. void rda_handler() {
95.  
96.    CharRcv=0;
97.    if(kbhit()){
98.       CharRcv=getc();
99.       if(CharRcv!=0){
100.          Command=CharRcv;
101.       }
102.    }
103. }
104.  
105. #int_ext
106. ext_handler() {
107.  
108.    long t;
109.    long n;
110.  
111.    disable_interrupts(int_timer1);
112.    disable_interrupts(int_ext1);
113.    disable_interrupts(int_ext2);
114.    ++nTintext;
115.    if(nTintext==1){
116.       set_timer1(0);
117.       nTimer1Overflow=0;
118.    }
119.    n=nTimer1Overflow;
120.    t=get_timer1();
121.  
122.    if(fedge1==0){
123.       ext_int_edge(0,L_TO_H);
124.       tDownI[uTimeDown]=n;
125.       tDownT[uTimeDown]=t;
126.       tDownC[uTimeDown]=1;
127.       ++uTimeDown;
128.    }else
129.    {
130.       ext_int_edge(0,H_TO_L);
131.       tUpI[uTimeUp]=n;
132.       tUpT[uTimeUp]=t;
133.       tUpC[uTimeUp]=1;
134.       ++uTimeUp;
135.    }
136.    ++fedge1;
137.    if(bit_test(C2_SETTINGS,7)==1){
138.       enable_interrupts(int_ext1);
139.    }
140.    if(bit_test(C3_SETTINGS,7)==1){
141.       enable_interrupts(int_ext2);
142.    }
143.    enable_interrupts(int_timer1);
144. }
145.  
146. #int_ext1
147. ext1_handler() {
148.  
149.    long t;
150.    long n;
151.  
152.    disable_interrupts(int_timer1);
153.    disable_interrupts(int_ext);
154.    disable_interrupts(int_ext2);
155.    ++nTintext;
156.    if(nTintext==1){
157.       set_timer1(0);
158.       nTimer1Overflow=0;
159.    }
160.    n=nTimer1Overflow;
161.    t=get_timer1();
162.  
163.    if(fedge2==0){
164.       ext_int_edge(1,L_TO_H);
165.       tDownI[uTimeDown]=n;
166.       tDownT[uTimeDown]=t;
167.       tDownC[uTimeDown]=2;
168.       ++uTimeDown;
169.    }else
170.    {
171.       ext_int_edge(1,H_TO_L);
172.       tUpI[uTimeUp]=n;
173.       tUpT[uTimeUp]=t;
174.       tUpC[uTimeUp]=2;
175.       ++uTimeUp;
176.    }
177.    ++fedge2;
178.    if(bit_test(C1_SETTINGS,7)==1){
179.       enable_interrupts(int_ext);
180.    }
181.    if(bit_test(C3_SETTINGS,7)==1){
182.       enable_interrupts(int_ext2);
183.    }
184.    enable_interrupts(int_timer1);
185. }
186.  
187. #int_ext2
188. ext2_handler() {
189.  
190.    long t;
191.    long n;
192.  
193.    disable_interrupts(int_timer1);
194.    disable_interrupts(int_ext);
195.    disable_interrupts(int_ext1);
196.    ++nTintext;
197.    if(nTintext==1){
198.       set_timer1(0);
199.       nTimer1Overflow=0;
200.    }
201.    n=nTimer1Overflow;
202.    t=get_timer1();
203.  
204.    if(fedge3==0){
205.       ext_int_edge(2,L_TO_H);
206.       tDownI[uTimeDown]=n;
207.       tDownT[uTimeDown]=t;
208.       tDownC[uTimeDown]=3;
209.       ++uTimeDown;
210.    }else
211.    {
212.       ext_int_edge(2,H_TO_L);
213.       tUpI[uTimeUp]=n;
214.       tUpT[uTimeUp]=t;
215.       tUpC[uTimeUp]=3;
216.       ++uTimeUp;
217.    }
218.    ++fedge3;
219.    if(bit_test(C1_SETTINGS,7)==1){
220.       enable_interrupts(int_ext);
221.    }
222.    if(bit_test(C2_SETTINGS,7)==1){
223.       enable_interrupts(int_ext1);
224.    }
225.    enable_interrupts(int_timer1);
226. }
227.  
228. #int_timer1
229. timer1_handler(){
230.    ++nTimer1Overflow;
231. }
232.  
233. // ON_RESET /////////////////////////////////////////////////////////
234.  
235. void on_reset(int1 verbose){
236.  
237.    disable_interrupts(global);
238.    disable_interrupts(int_timer1);
239.    disable_interrupts(int_rda);
240.    disable_interrupts(int_ext);
241.    disable_interrupts(int_ext1);
242.    disable_interrupts(int_ext2);
243.  
244.    setup_adc_ports(NO_ANALOGS);
245.    setup_adc(ADC_OFF);
246.    setup_spi(FALSE);
247.    setup_psp(PSP_DISABLED);
248.    setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
249.    setup_timer_0(RTCC_OFF);
250.    setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
251.    setup_timer_2(T2_DISABLED,0,1);
252.    setup_timer_3(T3_DISABLED);
253.    setup_comparator(NC_NC_NC_NC);
254.    setup_vref(FALSE);
255.    port_b_pullups(FALSE);
256.    set_tris_b(0b00000111);
257.  
258.    for(i=0;i<NMUESTRAS;i++){ tUpT[i]=0; tUpI[i]=0; tUpC[i]=0; tDownT[i]=0; tDownI[i]=0; tDownC[i]=0;}
259.  
260.    nTintext=0;
261.    uTimeUp=0;
262.    uTimeDown=0;
263.    flag_recibe_config1=0;
264.    flag_recibe_config2=0;
265.    flag_recibe_config3=0;
266.  
267.    config_channels(verbose);
268.  
269.    delay_ms(100);
270.    // Habilito Canal 1
271.    if(bit_test(C1_SETTINGS,7)==1){
272.       enable_interrupts(int_ext);
273.       if(verbose){ printf("\r\nint_ext enabled\r\n");}
274.    }
275.    // Habilito Canal 2
276.    if(bit_test(C2_SETTINGS,7)==1){
277.       enable_interrupts(int_ext1);
278.       if(verbose){ printf("\r\nint_ext1 enabled\r\n");}
279.    }
280.    // Habilito Canal 3
281.    if(bit_test(C3_SETTINGS,7)==1){
282.       enable_interrupts(int_ext2);
283.       if(verbose){ printf("\r\nint_ext2 enabled\r\n");}
284.    }
285.    // Habilito Recepción RS232
286.    enable_interrupts(int_rda);
287.    
288.    // Habilito Interrupciones Global
289.    enable_interrupts(global);
290. }
291.  
292. // MAIN //////////////////////////////////////////////////////////////////
293.  
294. void main() {
295.  
296.    on_reset(0);
297.  
298.    do{
299.  
300.       if(Command!=0){
301.  
302.          // Accepta byte de configuracion para Channel 1
303.          if(flag_recibe_config1==1){
304.             set_channel1();
305.          }
306.          // Accepta byte de configuracion para Channel 2
307.          if(flag_recibe_config2==1){
308.             set_channel2();
309.          }
310.          // Accepta byte de configuracion para Channel 3
311.          if(flag_recibe_config3==1){
312.             set_channel3();
313.          }
314.  
315.          // Procesa cxommandos
316.          switch(Command){
317.  
318.             // Commands Telnet  - SOFT COMMANDS ---------------------
319.  
320.             case '?': menu_trans();
321.                       break;
322.             case SOFT_COMMAND_RESET :
323.                       on_reset(1);               // Reset
324.                       break;
325.             case SOFT_COMMAND_FIRMWARE:
326.                       friendly_firmware_trans(); // Send Firmaware
327.                       break;
328.             case SOFT_COMMAND_DATA :
329.                       friendly_data_trans();     // Send Data
330.                       break;
331.             case SOFT_COMMAND_CONFIG :
332.                       friendly_config_trans();   // Send Config
333.                       break;
334.             case SOFT_COMMAND_EEPROM :
335.                       friendly_eeprom_trans();   // Send EEPROM
336.                       break;
337.  
338.             // Commands Soft PC - HARD COMMANDS ---------------------
339.  
340.             case HARD_COMMAND_RESET :
341.                       on_reset(0);               // Reset
342.                       ack_trans();
343.                       break;
344.             case HARD_COMMAND_FIRMWARE:
345.                       hardy_firmware_trans();    // Send Firmaware
346.                       break;
347.             case HARD_COMMAND_DATA :
348.                       hardy_data_trans();        // Send Data
349.                       break;
350.             case HARD_COMMAND_CONFIG :
351.                       hardy_config_trans();      // Send Config
352.                       break;
353.             case HARD_COMMAND_CONFIG1 :          // Atento : siguiente recepción de Cfg Channel 1
354.                       flag_recibe_config1=1;
355.                       ack_trans();
356.                       break;
357.             case HARD_COMMAND_CONFIG2 :          // Atento : siguiente recepción de Cfg Channel 2
358.                       flag_recibe_config2=1;
359.                       ack_trans();
360.                       break;
361.             case HARD_COMMAND_CONFIG3 :          // Atento : siguiente recepción de Cfg Channel 3
362.                       flag_recibe_config3=1;
363.                       ack_trans();
364.                       break;
365.          }
366.          Command=0;
367.       }
368.  
369.    } while (TRUE);
370. }
371.  
372. // menu_trans ///////////////////////////////////////////////////////
373.  
374. void menu_trans(void){
375.  
376.    friendly_firmware_trans();
377.  
378.    printf("Telnet format:\r\n\n");
379.    printf("  %c  reset tables\r\n",     SOFT_COMMAND_RESET);
380.    printf("  %c  version firmware\r\n", SOFT_COMMAND_FIRMWARE);
381.    printf("  %c  config transmit\r\n",  SOFT_COMMAND_CONFIG);
382.    printf("  %c  data transmit\r\n",    SOFT_COMMAND_DATA);
383.    printf("  %c  eeprom transmit\r\n",  SOFT_COMMAND_EEPROM);
384.    printf("\r\n");
385.    printf("Hardware format:\r\n\n");
386.    printf("  %c  reset tables\r\n",     HARD_COMMAND_RESET);
387.    printf("  %c  version firmware\r\n", HARD_COMMAND_FIRMWARE);
388.    printf("  %c  data transmit\r\n",    HARD_COMMAND_DATA);
389.    printf("  %c  config transmit\r\n",  HARD_COMMAND_CONFIG);
390.    printf("  %cb config Channel1\r\n",  HARD_COMMAND_CONFIG1);
391.    printf("  %cb config Channel2\r\n",  HARD_COMMAND_CONFIG2);
392.    printf("  %cb config Channel3\r\n",  HARD_COMMAND_CONFIG3);
393.    printf("\r\n");
394.  
395. }
396.  
397. // Set Canal ////////////////////////////////////////////////////////
398.  
399. void set_channel1(void){
400.  
401.    flag_recibe_config1=0;
402.    C1_Settings=Command;
403.    Command=0;
404.    write_eeprom(DIR_C1_SETTINGS,C1_SETTINGS);
405.    delay_ms(10);
406.    ack_trans();
407. }
408.  
409. void set_channel2(void){
410.  
411.    flag_recibe_config2=0;
412.    C2_Settings=Command;
413.    Command=0;
414.    write_eeprom(DIR_C2_SETTINGS,C2_SETTINGS);
415.    delay_ms(10);
416.    ack_trans();
417. }
418.  
419. void set_channel3(void){
420.  
421.    flag_recibe_config3=0;
422.    C3_Settings=Command;
423.    Command=0;
424.    write_eeprom(DIR_C3_SETTINGS,C3_SETTINGS);
425.    delay_ms(10);
426.    ack_trans();
427. }
428.  
429. void config_channels(int1 verbose){
430.  
431.    // Recupero configuracion desde la EEPROM
432.    C1_SETTINGS = read_eeprom(DIR_C1_SETTINGS);
433.    C2_SETTINGS = read_eeprom(DIR_C2_SETTINGS);
434.    C3_SETTINGS = read_eeprom(DIR_C3_SETTINGS);
435.    if(verbose){ printf("\r\Config 1=%u 2=%u 3=%u\r\n",C1_SETTINGS,C2_SETTINGS,C3_SETTINGS);}
436.    // Configuro Channel1 Flanco inicial
437.    if(bit_test(C1_SETTINGS,7)==1){
438.      if(bit_test(C1_SETTINGS,5)==1){
439.         fedge1=0;
440.         ext_int_edge(0,H_TO_L);
441.         if(verbose){ printf("\r\nint_ext 0 H_to_L\r\n");}
442.      }
443.      if(bit_test(C1_SETTINGS,6)==1){
444.         fedge1=1;
445.         ext_int_edge(0,L_TO_H);
446.         if(verbose){ printf("\r\nint_ext 1 L_to_H\r\n");}
447.      }
448.    }
449.    // Configuro Channel2 Flanco inicial
450.    if(bit_test(C2_SETTINGS,7)==1){
451.      if(bit_test(C2_SETTINGS,5)==1){
452.         fedge2=0;
453.         ext_int_edge(1,H_TO_L);
454.         if(verbose){ printf("\r\nint_ext1 0 H_to_L\r\n");}
455.      }
456.      if(bit_test(C2_SETTINGS,6)==1){
457.         fedge2=1;
458.         ext_int_edge(1,L_TO_H);
459.         if(verbose){ printf("\r\nint_ext1 1 L_to_H\r\n");}
460.      }
461.    }
462.    // Configuro Channel3 Flanco inicial
463.    if(bit_test(C3_SETTINGS,7)==1){
464.      if(bit_test(C3_SETTINGS,5)==1){
465.         fedge3=0;
466.         ext_int_edge(2,H_TO_L);
467.         if(verbose){ printf("\r\nint_ext2 0 H_to_L\r\n");}
468.      }
469.      if(bit_test(C3_SETTINGS,6)==1){
470.         fedge3=1;
471.         ext_int_edge(2,L_TO_H);
472.         if(verbose){ printf("\r\nint_ext2 1 L_to_H\r\n");}
473.      }
474.    }
475. }
476.  
477. // ack_trans ////////////////////////////////////////////////////////
478.  
479. void ack_trans(void){
480.  
481.    printf("%c\r\n",RESPONSE_ACK);
482. }
483.  
484. // eeprom_trans /////////////////////////////////////////////////////
485.  
486. void friendly_eeprom_trans(void){
487.  
488.    int i,j,u;
489.  
490.    printf("\r\n");
491.    for(i=0;i<16;i++) printf("%X ",i);
492.    printf("\r\n");
493.    for(i=0;i<16;i++) printf("== ");
494.    printf("\r\n");
495.    j=0;
496.    for(i=0;i<255;i++){
497.      u=read_eeprom(i);
498.      printf("%X ",u);
499.      if(++j>15){
500.        j=0;
501.        printf("\r\n");
502.      }
503.    }
504.    u=read_eeprom(255);
505.    printf("%X ",u);
506.    printf("\r\n\r\n");
507. }
508.  
509. // firmware_trans ///////////////////////////////////////////////////
510.  
511. void friendly_firmware_trans(void){
512.  
513.    printf("\r\nLogical Analyzer v.%s by Redpic\r\n\n",Version);
514. }
515.  
516. void hardy_firmware_trans(void){
517.  
518.    printf("{%s}\r\n",Version);
519.    delay_ms(10);
520.    ack_trans();
521. }
522.  
523. // data_trans ///////////////////////////////////////////////////////
524.  
525. void friendly_data_trans(void){
526.  
527.    disable_interrupts(int_timer1);
528.  
529.    printf("\r\nResults Table:\r\n\n");
530.  
531.    printf("Total INT_EXT detected %2u\r\n",nTintext);
532.  
533.    printf("\r\nFalling edges Table\r\n\n");
534.    printf("Nº C   Overflows  Timer\r\n");
535.    printf("=======================\r\n");
536.    for(i=0;i<NMUESTRAS;i++){
537.       printf("%2u %1u       %5lu  %5lu\r\n",i,tDownC[i],tDownI[i],tDownT[i]);
538.    }
539.    printf("\r\n\nRising edges Table\r\n\n");
540.    printf("Nº C   Overflows  Timer\r\n");
541.    printf("=======================\r\n");
542.    for(i=0;i<NMUESTRAS;i++){
543.       printf("%2u %1u       %5lu  %5lu\r\n",i,tUpC[i],tUpI[i],tUpT[i]);
544.    }
545. }
546.  
547. void hardy_data_trans(void){
548.  
549.    disable_interrupts(int_timer1);
550.  
551.    for(i=0;i<NMUESTRAS;i++){
552.       printf("{ %3u %1u %5lu %5lu %1u %5lu %5lu }\r\n",i+1,tUpC[i],tUpI[i],tUpT[i],tDownC[i],tDownI[i],tDownT[i]);
553.    }
554.    delay_ms(10);
555.    ack_trans();
556. }
557.  
558. // config_trans /////////////////////////////////////////////////////
559.  
560. void friendly_config_trans(void){
561.  
562.    disable_interrupts(int_timer1);
563.  
564.    printf("\r\nConfig Channels :\r\n\n");
565.  
566.    printf("Channel 1 = %2u\r\n\n",C1_Settings);
567.    printf("Channel 2 = %2u\r\n\n",C2_Settings);
568.    printf("Channel 3 = %2u\r\n\n",C3_Settings);
569. }
570.  
571. void hardy_config_trans(void){
572.  
573.    disable_interrupts(int_timer1);
574.  
575.    printf("{ %3u %3u %3u }\r\n",C1_Settings,C2_Settings,C3_Settings);
576.    delay_ms(10);
577.    ack_trans();
578. }
579. ///////////////////////////////////////////////////////////////////////////////////////////////////
580.  

Buenoooooo .... sé que a este proyecto se le pueden (y deben) hacer docenas de ampliaciones y mejoras. Algunas ya las tengo claras como por ejemplo la de colocarle un delay ajustable antes de comenzar a samplear, es fundamental para señales que tienen un periodo de latencia alto y de la que queremos investigar partes mas avanzadas de las que la sonda tiene posibilidad de rastrear, tambien se debería poder ajustar que el sampleado comienze a partir de un número determinado de interrupciones recibidas por un canal en concreto. también ....

Pero por ahora se va a quedar así. Hay otros proyectos que esperan que les meta mano y ... hay que seguir avanzando, hasta llegar allí donde nunca antes nadie ha estado.     

Os mantendré informados.

[Nocturno]

Enhorabuena, Don Diego. Eres rápido como el rayo.

Cuando mi osciloscopio desde la mesa ha visto la foto de tu sonda lógica y las palabras "PROYECTO TERMINADO" se le han caído dos lagrimones y luego me ha mirado con una cara muy rara.
Qué envidiaaaaaaaaaaaaaaaaaa.

En fin, si esta es la versión 1.0.6 no me quiero ni imaginar qué será cuando vayas por la 3.4.8.
Enhorabuena otra vez.

[dogflu66]

Felicidades Diego, y todo con acabado profesional... 

[Sispic]

Vaya , eres de los pocos que terminan proyectos .  En hora buena

don PROYECTO TERMINADO

Good Herramienta .

[RaDoN]

Im-presionante, felicidades diego!! 

[jfh900]

Enhora buena por la terminación del proyecto, ha quedado muy profesional.

Un saludo.

[RedPic]

Gracias, gracias ... me siento abrumado 

(  )

[Manofwar]

Que máquina Redpic, enhorabuena por ese pedazo de PROYECTO con mayúsculas.