Autor Tema: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en Alto con INTEXT  (Leído 16302 veces)

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

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
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 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.



B.- Técnica 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 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 Int_Ext 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 es:

1.- Configuraremos la Int_Ext por RB0 para detectar inicialmente el Flanco de Subida.
2.- Al llegarnos este Flanco de Subida guardaremos el valor en ese momento de TIMER1 y ...
3.- Cambiaremos la configuración de la Int_Ext por RB0 para detectar el siguiente Flanco de Bajada.
4.- Cuando nos llegue el Flanco de Bajada guardaremos de nuevo el valor de TIMER1 y ...
5.- Volveremos a configurar la Int_Ext por RB0 para detectar de nuevo un Flanco de Subida. Y ...
6.- 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.

C.- Implementación en C:

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

Para configurar inicialmente el flanco de subida a detectar utilizaremos:

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

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

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

Código: C
  1. #int_ext
  2. void handle_ext_int(){
  3.  
  4.    if(flagToggleFlanco==0){                 // He recibido Flanco de Subida
  5.      
  6.       t1=get_timer1();                      // Guardo en t1 el valor de TMR1 al Flanco de Subida
  7.       ext_int_edge(0,H_TO_L);               // Configuro para capturar siguiente flanco de Bajada
  8.       flagToggleFlanco=1;                   // Indico que el siguiente flanco será de Bajada
  9.  
  10.    } else {                                 // He recibido Flanco de Bajada
  11.  
  12.       t2=get_timer1();                      // Guardo en t2 el valor de TMR1 al Flanco de Bajada
  13.       ext_int_edge(0,L_TO_H);               // Configuro para capturar siguiente flanco de subida
  14.       flagToggleFlanco=0;                   // Indico que el siguiente flanco será de Subida
  15.       set_timer1(0);                        // Reinicio TMR1
  16.       if(flagHayDatos==0){                  // Si los datos anteriores han sido procesados ...
  17.          flagHayDatos=1;                    // Indico que ya hay nuevos datos de flancos para calcular
  18.       }
  19.    }
  20. }
  21.  

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

Código: C
  1.       if(flagHayDatos==1){                  // Detecto que ya hay datos de flancos ...
  2.          if(t2 > t1){                       // Compruebo que estoy en la misma vuelta de TMR1
  3.             tt = t2 - t1;                   // Calculo en Tick's de TMR1 el tiempo entre flancos
  4.             st = uSxTick * tt;              // Calculo en uS el tiempo.
  5.             flagHayTransmitir=1;            // Indico que tengo nuevo valor para transmitir
  6.          }
  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 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 asi su desborde.

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

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

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

Código: C
  1.       if(Command!=0x00){                    // Si he recibido un comando vía Serie ...
  2.          if(Command=='T'){                  // Si el comando es 'T' (Transmite) ...
  3.             if(flagHayTransmitir==1){       // Si hay algo pendiente de transmitir ...
  4.                printf("Ticks %Lu - %Lu = %Lu = %3.1fuS \r\n",t2,t1,tt,st);
  5.                flagHayTransmitir=0;         // Indico que ya he transmitido lo pendiente.
  6.             }
  7.          }
  8.          Command=0x00;                      // Indico que ya he procesado el comando.
  9.       }
  10.  

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

Código: C
  1. ////////////////////////////////////////////////////////////////////////////////////
  2. //
  3. // Midiendo_un_pulso_1_Width_High.c
  4. //
  5. // SERIE: "Técnicas en C" para el Foro TODOPIC
  6. //
  7. // (c) 10.2006 by RedPic
  8. //
  9. // Propósito: Medir el tiempo que permanece un pulso en alto
  10. //
  11. // Condiciones de Test: Inyección por RB0 de una señal de 2 Khz (0.5 ms de periodo)
  12. //
  13. // Técnica Empleada: Detectar mediante la Interrupción Externa por RB0
  14. //                   un flanco de subida de un pulso, guardar el estado
  15. //                   de TMR1,  detectar  a  continuación el  siguiente
  16. //                   flanco de bajada, guardar el nuevo estado de TMR1,
  17. //                   realizar las substracción de ambos para obtener el
  18. //                   tiempo que permanece en alto y transmitir mediante
  19. //                   el puerto RS232 a petición.
  20. //
  21. ////////////////////////////////////////////////////////////////////////////////////
  22.  
  23. #include <18f4550.h>
  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 Constantes
  32. //
  33. ////////////////////////////////////////////////////////////////////////////////////
  34.  
  35. #define LED PIN_E0                          // Defino el Pin del Led
  36. #define FLASH Output_Toggle(LED)            // Defino la funcion Flash de monitor
  37.  
  38. float const uSxTick = 0.2;                  // Microsegundos por Tick de TMR1 a 20 Mhz
  39.  
  40. ////////////////////////////////////////////////////////////////////////////////////
  41. //
  42. // Variables en RAM
  43. //
  44. ////////////////////////////////////////////////////////////////////////////////////
  45.  
  46. char  cRec=0x00;                            // Último caracter recibido via serie
  47. char  Command=0x00;                         // Comando a procesar
  48. int1  flagToggleFlanco=0;                   // Flag para cambiar de flanco
  49. int16 t1=0x00,t2=0x00,tt=0x00;              // Variables para guardar estados de ...
  50. float st=0.0;                               // TMR1 en cada flanco y hacer la resta
  51. int1  flagHayDatos=0;                       // Flag para indicar que ya hay datos de ..
  52.                                             // dos flancos (de subida y bajada)
  53. int1  flagHayTransmitir=0;                  // Flag para indicar que hay datos para ...
  54.                                             // Transmitir al PC.
  55.  
  56. ////////////////////////////////////////////////////////////////////////////////////
  57. //
  58. // Interrupción por Recepción Serie RS232
  59. //
  60. ////////////////////////////////////////////////////////////////////////////////////
  61.  
  62. #int_rda
  63. 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 procesarlo
  69.       }                                     // pasándolo a Mayúsculas para no confundir.
  70.    }
  71. }
  72.  
  73. ////////////////////////////////////////////////////////////////////////////////////
  74. //
  75. // Interrupción por Externa por Cambio de Flanco en RB0
  76. //
  77. ////////////////////////////////////////////////////////////////////////////////////
  78.  
  79. #int_ext
  80. void handle_ext_int(){
  81.  
  82.    if(flagToggleFlanco==0){                 // He recibido Flanco de Subida
  83.      
  84.       t1=get_timer1();                      // Guardo en t1 el valor de TMR1 al Flanco de Subida
  85.       ext_int_edge(0,H_TO_L);               // Configuro para capturar siguiente flanco de Bajada
  86.       flagToggleFlanco=1;                   // Indico que el siguiente flanco será de Bajada
  87.  
  88.    } else {                                 // He recibido Flanco de Bajada
  89.  
  90.       t2=get_timer1();                      // Guardo en t2 el valor de TMR1 al Flanco de Bajada
  91.       ext_int_edge(0,L_TO_H);               // Configuro para capturar siguiente flanco de subida
  92.       flagToggleFlanco=0;                   // Indico que el siguiente flanco será de Subida
  93.       set_timer1(0);                        // Reinicio TMR1
  94.       if(flagHayDatos==0){                  // Si los datos anteriores han sido procesados ...
  95.          flagHayDatos=1;                    // Indico que ya hay nuevos datos de flancos para calcular
  96.       }
  97.    }
  98.    FLASH;                                   // Reproduzco la entrada mediante un LEd en E0;
  99. }
  100.  
  101. void main() {
  102.  
  103.     ////////////////////////////////////////// INICIALIZACIONES GENERALES
  104.  
  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);
  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 como entrada RC7 para canal RS232
  129.                                            
  130.    ext_int_edge(0,L_TO_H);                  // Configuro captura de 1er flanco de subida
  131.    flagToggleFlanco = 0;                    // inicializo el Flag para cambiar de flanco
  132.  
  133.    enable_interrupts(int_rda);              // Habilito las interrupciones necesarias
  134.    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 TMR1
  144.             tt = t2 - t1;                   // Calculo en Tick's de TMR1 el tiempo entre flancos
  145.             st = uSxTick * tt;              // Calculo en uS el tiempo.
  146.             flagHayTransmitir=1;            // Indico que tengo nuevo valor para transmitir
  147.          }
  148.          flagHayDatos=0;                    // Indico que ya han sido procesados los datos.
  149.       }
  150.       if(Command!=0x00){                    // Si he recibido un comando vía Serie ...
  151.          if(Command=='T'){                  // Si el comando es 'T' (Transmite) ...
  152.             if(flagHayTransmitir==1){       // Si hay algo pendiente 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 he procesado el comando.
  160.       }
  161.    } while (TRUE);
  162. }
  163.  

D.- Ejemplo funcionando:



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

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

Desconectado Cryn

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4169
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High
« Respuesta #1 en: 21 de Octubre de 2006, 23:34:06 »
hola, saludos muy interesante trabajo, y precisamente viene con algo que necesitaba, bueno talvez puedas ayudarme, dispongo de un 16f84a (no creo que sirva para este trabajo de medición ya que no posee tmr1), pero puedo disponer de un 16f877a, asi que no hay problema con ello; mira monte este trabajo al foro del que no tuve respuestas: http://www.todopic.com.ar/foros/index.php?topic=14123.0

Es un programa para detectar el protocolo Sony Sirc de un control remoto (IR) de TV; creo que tengo problemas con los tiempos, no se si seran los correctos los que me da la pagina: http://www.sbprojects.com/knowledge/ir/sirc.htm ya que he visto por otro lado que son distintos:
cabecera: 2.6ms en '1' y 400us en '0'
dato 0: 800us en '1' y 400us en '0'
dato 1: 1400us en '1' y 400us en '0'

he probado estos y nada, he probado con los tiempos de la pagina sbprojects y nada; talvez sea algun error en mi programa, si podes ayudarme te lo agradeceria.

Lo que quisiera intentar para estar seguro es medir los tiempos con un tmr1, pasa que una trama no pasa de 25ms y hay mucha información, un bit de start y 12 bits de datos; tendria que medir si o si el primero (start) y despues un uno y un cero y basta, o leer todo, nose; alguna sugerencia?? ayuda, porfavor

muchas gracais, chao.

pd. me parece que podria usar rs-232 para visualizar los datos obtenidos, gracias, chao.
.

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High
« Respuesta #2 en: 22 de Octubre de 2006, 04:46:34 »
Cryn:

He utilizado el TMR1 porque existe en la mayoria de los PIC's y es de 16 bits por lo que admite longitudes de pulsos bastante largas.

De todas formas todo lo dicho para TMR1 es válido para TMR0 aunque sea de 8 bits. Si el pulso es mas largo que la resolución que nos dá TMR0 se pueden hacer dos cosas:

1º.- Contar ademas de los ticks del Timer las vueltas completas que dá dicho timer, acumulandolas usando la interrupción RTCC de desbordamiento de Contador. Asi el ancho del pulso seria (Nº Vueltas * Tiempo x Vuelta) + (Nº de Ticks * Tiempo x Tick)

2º.- Aplicar un Preescaler a TMR0 dividiendolo por 4, 6, 8 ... 256 haciendo que vaya mas lento y podamos asi capturar periodos mas largos.

En cuanto a lo de los IR dale un vistazo a:

En inglés IR Remote Knowledge Base
En Español EXPERIMENTOS : INFRARROJOS


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

Desconectado 5GTT

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 915
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High
« Respuesta #3 en: 22 de Octubre de 2006, 22:04:13 »
Como siempre magistral. Una vez mas, Gracias.

Lo que aun no acabo de entender es como se me habia pasado por alto ese articulo sobre IR de tu web, muy interesante.

Saludos.

Tutoriales y proyectos de electrónica

Desconectado Cryn

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 4169
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ext
« Respuesta #4 en: 25 de Octubre de 2006, 20:11:26 »
Hola saludos, la pagina en ingles es la que deje de enlace, ya la vi, la de español alguna vez tb la vi; ahi usan los tiempos que supongo son los correctos, bueno seguire buscando errores en el codigo de c.

pero talvez el programa que hiciste pueda servir para detectar los protocolos de otros controles remotos que no estan ahi, talvez un samsumg, o un aiwa, lg, etc; bueno yo tb intentare hacerlo, cualquier cosa os comunico, adios
.

Desconectado filth

  • PIC10
  • *
  • Mensajes: 6
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ex
« Respuesta #5 en: 26 de Octubre de 2006, 08:32:02 »
Hola a todos!!

Me gustaría saber si también se puede medir el ancho de pulso con el PIN_B5. Lo que quiero es medir el ancho de pulso del eco de un SRF04 mediante interrupciones conectándolo a dicho pin.

Un saludo y gracias de antemano

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ext
« Respuesta #6 en: 26 de Octubre de 2006, 09:53:34 »
Filth:

¿Que PIC? ¿Que dice su Datasheet del pin RB5? ¿Podemos hacer uso de alguna función en concreto en ese pin? ¿Tiene ese pin en tu PIC alguna interrupción utilizable como la de Cambio de Estado por ejemplo? ¿Por qué RB5 en lugar de RB0? ¿Tienes en uso RB0? ¿Es posible pasar a RB5 lo que ahora tienes en RB0 y usar RB0 para la Int_Ext? ¿Tienes CCP en algun otro pin no utilizado?

Ja,ja,ja  :D  :D  :D perdona si te he hecho mas preguntas de la cuenta pero son las que yo me haría a mi mismo para poder contestarte adecuadamente y que te sirva de algo.  :mrgreen:
 
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado filth

  • PIC10
  • *
  • Mensajes: 6
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ex
« Respuesta #7 en: 26 de Octubre de 2006, 11:29:03 »
Lo primero, gracias por tu interés RedPic. Ahora trataré de responder a tus preguntas. El PIC que utilizo es un 16F877, si no me equivoco el RB5 es sensible a los cambios de nivel en la señal.

Pretendo utilizar RB5 y no el RB0 porque en el 0 tengo un circuito de reset. Quizá pueda cambiar el circuito de pin...

Lo del CCP no me lo he planteado.

Gracias

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ext
« Respuesta #8 en: 26 de Octubre de 2006, 14:39:03 »
filth:

Consultado el Datasheet del 877 (imagino que encapsulado de 40 pines).  :mrgreen:

Tienes disponible el CCP1 por RC2 y el CCP2 por RC1 y si usas la técnica Midiendo un pulso. 3ª Parte. Tiempo en High con Int_CCP creo que lo tienes todo.  :)

De todas formas aclarame lo del reset ... ¿por RB0? ¿para detectar algo externo? por que generalmente se usa el Pin 1 MCLR/Vpp con esta configuración:



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

Desconectado filth

  • PIC10
  • *
  • Mensajes: 6
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ex
« Respuesta #9 en: 26 de Octubre de 2006, 20:13:45 »
Buenas de nuevo.

Veré lo de CCP. Sobre lo del reset creo que está ocupado, o al menos eso entiendo yo viendo las hojas características de la placa del robot sobre el que estoy trabajando. Se trata de un Mark III:

Aquí página del robot

Mi idea es ponerle el SRF04 para poder medir distancias y a la vez controlar los servos, por eso creo que necesito el uso de interrupciones. ¿Lo estoy intentando hacer de la forma correcta?

Un saludo, gracias

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ext
« Respuesta #10 en: 27 de Octubre de 2006, 01:26:09 »
Sobre el SRF04 tengo un hilo abierto en el foro: Medidor de distancias mediante Ultrasonidos SFR04 Dale un vistazo y despues lo comentamos.

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

Desconectado filth

  • PIC10
  • *
  • Mensajes: 6
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ex
« Respuesta #11 en: 27 de Octubre de 2006, 05:44:30 »
Hola!!

Ya he visto ese hilo, de hecho es el código sobre el que estoy trabajando. Pero lo que pretendo es pasarlo al pin RB5 y atenderlo por interrupción y cambiar los delay por interrupciones de temporizador, para no tener tiempos muertos y poder estar permanentemente pendiente de los servos.

Un saludo, gracias

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ext
« Respuesta #12 en: 27 de Octubre de 2006, 08:37:00 »
En cuanto llegue a casa te pongo el código completo del ejemplo usando el CCP por RB3 que tengo para mi 18F4550.

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

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5416
    • Picmania by Redraven
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en High con Int_Ex
« Respuesta #13 en: 28 de Octubre de 2006, 20:11:30 »
Hola!!

Ya he visto ese hilo, de hecho es el código sobre el que estoy trabajando. Pero lo que pretendo es pasarlo al pin RB5 y atenderlo por interrupción y cambiar los delay por interrupciones de temporizador, para no tener tiempos muertos y poder estar permanentemente pendiente de los servos.

Un saludo, gracias

Amigo Filth:

Elige el pin que desees ...  :mrgreen:

Midiendo un pulso. 1ª Parte. Tiempo en Alto con INTEXT por el Pin RB0
Midiendo un pulso. 2ª Parte. Tiempo en Alto con INTCCP por los Pines RC1 ó RC2 (y dependiendo del PIC RB3)
Midiendo un pulso. 3ª Parte. Tiempo en Alto con INTRB por los Pines RB4, RB5, RB6 ó RB7

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

Desconectado filth

  • PIC10
  • *
  • Mensajes: 6
Re: Serie Técnicas en C : Midiendo un pulso. 1ª Parte. Tiempo en Alto con INTEXT
« Respuesta #14 en: 30 de Octubre de 2006, 07:51:23 »
A tus pies maestro!!!

Muchas gracias por tu ayuda y tu interés. Me voy a poner a ver si consigo juntarlo todo, ya te comentaré mis evoluciones. Una vez más gracias.

Un saludo