Autor Tema: Problema con desestabilización de los timer´s  (Leído 3450 veces)

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

Desconectado Thulsa Doom

  • PIC24F
  • *****
  • Mensajes: 771
    • https://electronicadicto.wordpress.com/
Problema con desestabilización de los timer´s
« en: 06 de Enero de 2012, 08:58:38 »
Hola a todos, tengo un problema al intentar hacer un cronómetro con cualquiera de los timer´s del pic a ver si me pueden orientar .
Resulta que si monto un cronómetro utilizando la interrupción del TIMER1 por ejemplo, y muestro los valores de los minutos y segundos en pantalla, (solo eso), el cronómetro es estable, me cuesta mucho dejarlo ajustado a la cuenta de un cronómetro real, según he leído dicen que eso es imposible.
Yo lo he intentado pero cuando cargo el buffer, por ejemplo con esto 65480 me va más rápido que un conteo normal estándar, y si le cambio solo un dígito, por ejemplo 65489, me va más lento, no consigo ajustarlo a ver si me pueden ayudar en eso.

Otra cosa que me pasa es que si empiezo a meterle código, el cronómetro se me desestabiliza y no me hace el conteo simétrico, me refiero que empieza a contar bien pero cada 5 segundos cuenta el siguiente dos veces, como que utiliza un ciclo más que los demás conteos

Una de las cosas que al parecer no le sienta bien son los delays, cada vez que en el código utilizo un delay, da igual donde lo ponga, cuando compilo, el compilador me da este warning:

Código: [Seleccionar]
>>>Warning216”timer1.c”Line86(0,1):Interrupts disabled during call to prevent re-entrancy: (@delay_ms1)
Según interpreto me está diciendo que mientras este el delay se desactivan las interrupciones
Yo pensaba que las interrupciones de los timers trabajan ajenas a la ejecución del programa general, que se carga el buffer y mientras se ejecuta el programa  este se va ejecutando hasta que se desborda y atiende el código que está en la interrupción, por eso no entiendo que mientras haya un delay no se atienda la interrupción.

Por ejemplo si hago este código:
Código: [Seleccionar]
#include "C:\Documents and Settings\Programacion\Escritorio\timer1\timer1.h"
//****************************Definiciones de pines***********************
      #define start PIN_B6  //Interruptor de comienzo
      #define LED PIN_A2   //Led que indica que el sistema está en ejecución
      
      
//*****************************Declaraciones Globales***************************

   int mlseg=999,seg=59,min=59;
   int switchstart;  
//*****************************Interrupciones***********************************

#int_TIMER1
void TIMER1_isr(){
    int limitemlseg=999;
    int limiteseg=59;
    int limitemin=59;
    set_timer1(65480);
    
    if(switchstart==1){
       mlseg--;
     if(mlseg > limitemlseg){
        mlseg=999;
        if(mlseg==limitemlseg){
          seg--;
          if(seg > limiteseg){
            seg=59;
            if(seg == limiteseg){
               min--;
               if(min > limitemin){
                 min=59;
               }
            }
          }
        }
     }
   }
}

#int_RB
 
 void RB_isr(){ //Interrupción que atiende a los puertos entre B4 y B7
   int limitestart=1;

   if(input(start)==0){
      delay_ms(20);
      if(input(start)==0){
         switchstart++;
        if(switchstart > limitestart){
           switchstart = 0;
      }
    }
  }
}
//****************************Subrutinas****************************************
void ledverde(){
output_high(LED);
delay_ms(100);
output_low(LED);
delay_ms(300);
}


//****************************Programa Principal********************************
void main(){
  
    
   port_b_pullups(true);
   set_timer1(65480);  //Carga del buffer del timer1 para que el salto sea a 1 ms
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_1);  //Configuración del timer1 para el cronómetro
   enable_interrupts(INT_TIMER1);
   enable_interrupts(INT_RB);
   enable_interrupts(global);   //Activamos las interrupciones globales
   lcd_init();
  
   while(TRUE){
       lcd_putc("\f");
       lcd_gotoxy(1,1); printf(lcd_putc,"TIEMPO");
       lcd_gotoxy(1,2); printf(lcd_putc,"%02u:%02u",min,seg);
      
       ledverde();
      
   }
}
Si dejo la subrutina del ledverde(), el cronómetro se hace inestable pero si la saco se vuelve estable.
¿Hay alguna manera de arreglar esto y que no se desequilibre el conteo cuando meto un delay?
« Última modificación: 06 de Enero de 2012, 09:00:57 por Thulsa Doom »
Más códigos y desarrollos en https://electronicadicto.wordpress.com/ date una vuelta y curiosea un rato...

Desconectado jukinch

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 608
Re: Problema con desestabilización de los timer´s
« Respuesta #1 en: 06 de Enero de 2012, 10:14:01 »
Hola Thulsa Doom:
                        Si las demoras que estableciste con delay_ms no requiriesen precisión te sugiero pruebes implementar una función de demora o retardo con un bucle while o for en reemplazo de delay_ms para que las interrupciones no se deshabiliten.
                    Saludos.
                         Jukinch
"Divide las dificultades que examinas en tantas partes como sea posible para su mejor solución." -René Descartes

Desconectado MerLiNz

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2463
Re: Problema con desestabilización de los timer´s
« Respuesta #2 en: 06 de Enero de 2012, 10:44:37 »
el problema es que no puedes ni poner tanto codigo, ni tampoco un delay en la interrupcion, imagina que entra a la interrupcion  RB, y a los pocos ms se activa el timer, al tener el delay de 20ms hasta que no salga de ahi no entrara al timer, por lo cual ese tiempo ya lo tienes perdido y te marcara mal.

Desconectado Thulsa Doom

  • PIC24F
  • *****
  • Mensajes: 771
    • https://electronicadicto.wordpress.com/
Re: Problema con desestabilización de los timer´s
« Respuesta #3 en: 06 de Enero de 2012, 11:00:40 »
 ¿Y cómo podría hacerlo?, alguien puede ponerme un ejemplo, soy novato, bueno llevo tiempo con esto pero es como si fuera novato.
Gracias
Más códigos y desarrollos en https://electronicadicto.wordpress.com/ date una vuelta y curiosea un rato...

Desconectado jukinch

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 608
Re: Problema con desestabilización de los timer´s
« Respuesta #4 en: 06 de Enero de 2012, 11:32:53 »
Thulsa Doom.
          Se me pasó lo de meter tantas cosas dentro de la interrupción. Como bien te ha dicho MerLiNz
          Debes reestructurar el código para trabajar eficientemente con interrupciones.
Para ello debés hacer lo menos posible dentro de la interrupción y avisar al programa principal que ocurrió el evento mediante el uso de una variable bandera o flag. Esto no es más que una variable de tipo booleana.


La idea en pseudo código es así:



INTERRUPCION:
     {
      BanderaOcurrioSuceso=1
     }


PROGRAMA PRINCIPAL:
      {
       Bucle principal
              {
                Si BanderaOcurrioSuceso==1
                     hacer
                            {
                            acá ponés el código que querés que haga el programa si sucede la
                             interrupción

                             y al final de esta rutina recordá que debés poner en cero la bandera.
                             BanderaOcurrioSuceso=0
                             }
                sino
                        {
                         seguir con el proceso normal
                         }
              }
       }
"Divide las dificultades que examinas en tantas partes como sea posible para su mejor solución." -René Descartes

Desconectado jukinch

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 608
Re: Problema con desestabilización de los timer´s
« Respuesta #5 en: 06 de Enero de 2012, 11:42:05 »
Aquí podés ver como trabaja con interrupciones el maestro RedPic en su Cronopic 1.0

http://picmania.garcia-cuervo.net/picc.php#CRONOPIC1
"Divide las dificultades que examinas en tantas partes como sea posible para su mejor solución." -René Descartes

Desconectado reiniertl

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1187
Re: Problema con desestabilización de los timer´s
« Respuesta #6 en: 06 de Enero de 2012, 11:58:39 »
Y además debes utilizar el TIMER en modo comparador con autorecarga. Es algo que TIMER1 puede hacer perfectamente. Así nunca tienes que volver a poner el valor de recarga en el TIMER por software.

Siendo el TIMER1 de 16 bits con dos registros de 8 bits (asumo que usas un PIC de 8 bits) no puedes actualizar la llamada set_timer1(65480); dentro de la ISR porque siempre  se consume tiempo en atender una ISR, lo peor es que nunca el tiempo es el mismo. Aunque el mecanismo de atención del uC siempre lleve el mismo tiempo, las interrupciones pueden estar temporalmente deshabilitadas, puede que el uC esté atendiendo otra interrupción cuando llega la solicitud de TIMER1, etc.

Lo mejor es que utilices el hw con las configuraciones adecuadas, ello evitará tener que utilizar la recarga por sw del temporizador, muy aconsejable si lo que intentas diseñar e implementar es un cronómetro.

Luego te queda aplicar las recomendaciones de jukinch

Un saludo
Reinier

Desconectado KALLITOS

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1256
Re: Problema con desestabilización de los timer´s
« Respuesta #7 en: 06 de Enero de 2012, 12:58:17 »
Lo mejor es que utilices el hw con las configuraciones adecuadas, ello evitará tener que utilizar la recarga por sw del temporizador, muy aconsejable si lo que intentas diseñar e implementar es un cronómetro.

Puedes usa el timer 2 como lo indica reiniertl, se autocarga el solo, esto es en los micros de 8 bits, si usas uno de 16 o mas, todos los timers tienen esa caracteristica de autocarga.

Usé el timer2 con el micro a 4Mhz y con la siguiente configuracion logre 100us

setup_timer_2 (T2_DIV_BY_1,49,2);       

Hice una hojita en excel para hacer calculos con el tmr2.

saludos
A un microcontrolador hay que sacarle hasta el ultimo byte....(YO)

Cómo puede ser que un pic24EP512 me quede corto de memoria, señores de MICROCHIP saquen pics con más memoria flash

Más de 45 mil lineas de codigo y aun no termino el equipo, asu mare!!

S34ML08G1TFI200 no necesito mas memoria externa.

Desconectado reiniertl

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1187
Re: Problema con desestabilización de los timer´s
« Respuesta #8 en: 06 de Enero de 2012, 13:19:30 »
La idea de Kallitos es excelente igualmente se puede utilizar un módulo CCP con el TIMER1 en modo comparación para lograr temporizaciones muy precisas sin necesidad de actualizar los registros del TIMER por software, lo que a mi juicio es LO PEOR que cualquiera puede hacer para tener una temporización precisa.

Ya con eso se resuelven casi todos los problemas de esta aplicación, y basta con escribir unos valores en algunos registros una sola vez.

Un saludo
Reinier
PD: Si el TIMER2 está libre no dudes en utilizarlo, al tener preescaler y poscaler es más flexible que TIMER1+CCP.

Desconectado Thulsa Doom

  • PIC24F
  • *****
  • Mensajes: 771
    • https://electronicadicto.wordpress.com/
Re: Problema con desestabilización de los timer´s
« Respuesta #9 en: 08 de Enero de 2012, 15:58:33 »
Hola a todos, he estado trabajando en las recomendaciones que me habéis dicho y tengo más dudas.

He intentado hacer el cronómetro con el TIMER1 + CCP para probarlo y creo haber leído que el ccp en modo comparación al llegar al valor del timer1 se resetea pero se activa la salida del pin del ccp1.
Si eso es así no me valdría ya que ese pin está conectado a uno de los pines del lcd.

He utilizado el timer2 y va bien, pero al intentar hacer el parpadeo del led, tanto con un bucle while como con un for, de esta manera
Código: [Seleccionar]
void ledverde(){
     long i=0,a=0;

   while(i<65533){
       output_high(LED);
       i++;
     }
   while(a<65534){
        output_low(LED);
        a++;
     }
}
Se queda enganchado en los bucles y no sale de ahí y no atiende a la interrupción, si bajo el valor 65534 a un valor de por ejemplo 300 si me funciona pero el bucle es tan rápido que el led se queda fijo iluminado.
Seguramente habrá otra manera de hacer `parpadear el led a la secuencia que yo quiera sin afectar a las interrupciones pero no tengo ni idea de cómo hacerlo, a ver si con algún ejemplo me queda claro.

El código que he modificado con vuestros consejos es este:
Código: [Seleccionar]
#include "C:\Documents and Settings\Thulsa_Doom\Escritorio\timer1\timer1.h"
//****************************Definiciones de pines***********************
      #define start PIN_B6  //Interruptor de comienzo
      #define LED PIN_A2   //Led que indica que el sistema está en ejecución
     
     
//*****************************Declaraciones Globales***************************

   int mlseg=999,seg=59,min=59;
   int switchstart; 
   char banderaTIMER2=0;
//*****************************Interrupciones***********************************

#int_TIMER2
void TIMER1_isr(){
       
   banderaTIMER2 = 1;
       
   }

void ledverde(){
     long i=0,a=0;

   while(i<65533){
       output_high(LED);
       i++;
     }
   while(a<65534){
        output_low(LED);
        a++;
     }
}
void main(){
   
   int limitemlseg=999;
    int limiteseg=59;
    int limitemin=59;
   
   port_b_pullups(true);
   setup_timer_2(T2_DIV_BY_1,250,1);
   enable_interrupts(INT_TIMER2);
   enable_interrupts(global);   //Activamos las interrupciones globales
   lcd_init();
   output_low(PIN_A4);
   
   while(TRUE){
   
   if(banderaTIMER2==1){
       mlseg--;
     if(mlseg > limitemlseg){
        mlseg=999;
        if(mlseg==limitemlseg){
          seg--;
          if(seg > limiteseg){
            seg=59;
            if(seg == limiteseg){
               min--;
               if(min > limitemin){
                 min=59;
               }
            }
          }
        }
     }
   
     banderaTIMER2=0;
  }
   
   else{
       lcd_putc("\f");
       lcd_gotoxy(1,1); printf(lcd_putc,"TIEMPO");
       lcd_gotoxy(1,2); printf(lcd_putc,"%02u:%02u",min,seg);
       ledverde();
       
       
   }
  }
}
Más códigos y desarrollos en https://electronicadicto.wordpress.com/ date una vuelta y curiosea un rato...

Desconectado KALLITOS

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1256
Re: Problema con desestabilización de los timer´s
« Respuesta #10 en: 08 de Enero de 2012, 16:48:32 »
Hola doom,

asegurate que la interrupcion sea un numero redondo y exacto, por ejemplo no sirven 1,001 ms ya que al acumulado existira un desfase

yo lo haria de la siguiente manera:

cristal Mhz   4   
set_timer2   249   
prescaler   4   
postcaler   1   
      
interrupcion   1000   uS
      
Código: C
  1. int16 milisegundos = 0;
  2. int8  segundos = 0;
  3. int8  minutos = 0;
  4. int8  horas = 0;
  5. int1  flag_segundos = 0;
  6.  
  7.  
  8. #int_timer2
  9. void timer2(void)
  10.    {
  11.    if(++milisegundos > 999)
  12.       {
  13.       milisegundos = 0;
  14.       flag_segundos = 1;
  15.       }  
  16.    if(milisegundos == 0)output_low(led);
  17.    if(milisegundos == 500)output_high(led);
  18.    }
  19.  
  20.  
  21.  
  22. void main (void)
  23. {
  24.  
  25. while(true)
  26.    {
  27.    if(flag_segundos)
  28.       {
  29.       flag_segundos = 0;
  30.      
  31.       ///aqui puedes poner la muestra en el lcd
  32.       ///esto ocurre cada 1 segundo
  33.      
  34.       if(++segundos > 59)
  35.          {
  36.          segundos = 0;
  37.          if(++minutos > 59)
  38.             {
  39.             minutos = 0;
  40.             if(++horas > 23)    
  41.                {
  42.                horas = 0;
  43.                }
  44.             }
  45.          }
  46.       }
  47.    }
  48. }

En el foro hay muchos ejemplos de este contador.

saludos.
A un microcontrolador hay que sacarle hasta el ultimo byte....(YO)

Cómo puede ser que un pic24EP512 me quede corto de memoria, señores de MICROCHIP saquen pics con más memoria flash

Más de 45 mil lineas de codigo y aun no termino el equipo, asu mare!!

S34ML08G1TFI200 no necesito mas memoria externa.

Desconectado reiniertl

  • Moderadores
  • PIC24H
  • *****
  • Mensajes: 1187
Re: Problema con desestabilización de los timer´s
« Respuesta #11 en: 09 de Enero de 2012, 10:27:45 »
Y existe un modo de deshabilitar la salida del módulo CPP en los pines del uC, basta con decirle que "en el evento OnCompare no cambie la salida". De esa forma sólo se utiliza internamente el periférico, sin cambios a la salida.

El código que te adjunto puede servirte si estás utilizando MPLAB+C18 en un PIC18:

Código: C
  1. #define  CONFIG_CPU_CLOCK_HZ  ( ( unsigned long ) 20000000 )
  2. #define  TIMER1_FOSC_SCALE     8
  3. #define  TIMER1__RATE_HZ  ((unsigned long) 1000)
  4. #define BIT_SET 1
  5.  
  6. static void vSetupTimerInterrupt( void )
  7.  
  8. {
  9.  
  10. const unsigned long ulConstCompareValue = ( ( CONFIG_CPU_CLOCK_HZ / TIMER1_FOSC_SCALE ) / TIMER1__RATE_HZ );
  11.  
  12. unsigned long ulCompareValue;
  13.  
  14. unsigned char ucByte;
  15.  
  16.  
  17.  
  18.         /* Interrupts are disabled when this function is called.
  19.  
  20.  
  21.  
  22.         Setup CCP1 to provide the tick interrupt using a compare match on timer
  23.  
  24.         1.
  25.  
  26.  
  27.  
  28.         Clear the time count then setup timer. */
  29.  
  30.         TMR1H = 0x00;
  31.  
  32.         TMR1L =  0x00;
  33.  
  34.  
  35.  
  36.         /* Set the compare match value. */
  37.  
  38.         ulCompareValue = ulConstCompareValue;
  39.  
  40.         CCPR1L = ( unsigned char ) ( ulCompareValue & ( unsigned long ) 0xff );
  41.  
  42.         ulCompareValue >>= ( unsigned long ) 8;
  43.  
  44.         CCPR1H = ( unsigned char ) ( ulCompareValue & ( unsigned long ) 0xff );
  45.  
  46.  
  47.  
  48.         CCP1CONbits.CCP1M0 = BIT_SET;   /*< Compare match mode. */
  49.  
  50.         CCP1CONbits.CCP1M1 = BIT_SET;   /*< Compare match mode. */
  51.  
  52.         CCP1CONbits.CCP1M2 = BIT_CLEAR; /*< Compare match mode. */
  53.  
  54.         CCP1CONbits.CCP1M3 = BIT_SET;   /*< Compare match mode. */
  55.  
  56.         PIE1bits.CCP1IE = BIT_SET;              /*< Interrupt enable. */
  57.  
  58.  
  59.  
  60.         /* We are only going to use the global interrupt bit, so set the peripheral
  61.  
  62.         bit to true. */
  63.  
  64.         INTCONbits.GIEL = BIT_SET;
  65.  
  66.  
  67.  
  68.         /* Provided library function for setting up the timer that will produce the
  69.  
  70.         tick. */
  71.  
  72.         OpenTimer1( T1_16BIT_RW & T1_SOURCE_INT & T1_PS_1_1 & T1_CCP1_T3_CCP2 );
  73.  
  74. }

Los #define los puedes poner en un lugar apropiado o sustituirlos directamente por los tuyos o los valores (siempre es bueno utilizar #define por comodidad)

El código funciona, lo he tomado del puerto para PIC18 de FreeRTOS y yo lo he utilizado otras veces. Este ejemplo te producirá una interrupción en el módulo CPP cada 100ms, pero puedes configurar el sistema  para que interrumpa en cualquier punto donde la combinación de preescaler+cristal te lo permita. Es muy eficaz porque el TIMER1 es reseteado por el módulo CPP y no tienes que escribir nada allí. La interrupción del CPP te servirá para atender el evento y la del TIMER1 debe estar deshabilitada.

Un saludo
Reinier

Desconectado Thulsa Doom

  • PIC24F
  • *****
  • Mensajes: 771
    • https://electronicadicto.wordpress.com/
Re: Problema con desestabilización de los timer´s
« Respuesta #12 en: 10 de Enero de 2012, 16:25:43 »
Hola doom,

asegurate que la interrupcion sea un numero redondo y exacto, por ejemplo no sirven 1,001 ms ya que al acumulado existira un desfase

yo lo haria de la siguiente manera:

cristal Mhz   4   
set_timer2   249   
prescaler   4   
postcaler   1   
      
interrupcion   1000   uS
      
Código: C
  1. int16 milisegundos = 0;
  2. int8  segundos = 0;
  3. int8  minutos = 0;
  4. int8  horas = 0;
  5. int1  flag_segundos = 0;
  6.  
  7.  
  8. #int_timer2
  9. void timer2(void)
  10.    {
  11.    if(++milisegundos > 999)
  12.       {
  13.       milisegundos = 0;
  14.       flag_segundos = 1;
  15.       }  
  16.    if(milisegundos == 0)output_low(led);
  17.    if(milisegundos == 500)output_high(led);
  18.    }
  19.  
  20.  
  21.  
  22. void main (void)
  23. {
  24.  
  25. while(true)
  26.    {
  27.    if(flag_segundos)
  28.       {
  29.       flag_segundos = 0;
  30.      
  31.       ///aqui puedes poner la muestra en el lcd
  32.       ///esto ocurre cada 1 segundo
  33.      
  34.       if(++segundos > 59)
  35.          {
  36.          segundos = 0;
  37.          if(++minutos > 59)
  38.             {
  39.             minutos = 0;
  40.             if(++horas > 23)    
  41.                {
  42.                horas = 0;
  43.                }
  44.             }
  45.          }
  46.       }
  47.    }
  48. }

En el foro hay muchos ejemplos de este contador.

saludos.


Pues he de dar las gracias a todos vosotros, la verdad que con ésta práctica me he dado cuenta de muchos errores que estaba cometiendo, seguro que tengo muchos más y los intentaré mejorar mis conocimientos con vuestra ayuda.
tengo mas dudas.
Me he dado cuenta de que si metes en la rutina del cronómetro un código que cambie según que salida activas, cambia la precisión del conteo, me explico
como pueden ver este código:

Código: [Seleccionar]
while(pulsadorstart==1)
  {
  if(flag_segundos){
     flag_segundos = 0;

     lcd_putc("\f");
     lcd_gotoxy(1,1); printf(lcd_putc,"TIEMPO");
     lcd_gotoxy(1,2); printf(lcd_putc,"%02u:%02u",min,seg);

 
    if(++segundos > 59){
        segundos = 0;
      if(++minutos > 59){
         minutos = 0;
        }
      }
    }
    if(pulsadorcara == 0)output_high(SSR1);
    if(pulsadorcara == 1){
      output_high(SSR2);
      }
     if(pulsadorcara == 2){
      output_high(SSR1);
      output_high(SSR2);
     }

  }

si activo la salida del SSR1 solo, pues ajusto el TIMER2 y va casi casi perfecto, pues dejando el mismo ajuste si activo el SSR1 y el SSR2 al mismo tiempo la cuenta ya cambia, con lo cual a la conclusión que he llegado es que yo puedo hacer todos los retrasos que quiera y bifurcaciones que quiera siempre que esté fuera del código principal del contador, si hago un código variable variará el cronómetro ya que cada instrucción gasta una cantidad de ciclos de reloj.
Entonces ¿no se puede guardar las instrucciones de salida (output_high(SSR1) y output_high(SSR2)) en una variable que se quedará fija en el programa principal y este al pasar por ella leerá el contenido de esa variable y activará la salida, consumiendo siempre el mismo tiempo?
No se si esto que digo es una tontería,

otra cosa amigo reiniertl
la verdad es que de c18 no se nada, yo estoy utilizando CCS C y un PIC 16F876A.
Con esto último que has puesto me has sacado de unas dudas que tenía, no sabía si al utilizar el timer1 con el ccp la interrupción tendría que ser la del ccp o la del timer1, pero eso ya me lo has aclarado, lo que no tengo ni idea de como anular la salida del modulo ccp, en lo que he leído al parecer el ccp espera a que un cambio de estado del pin ccp para que actúe la interrupción, ahí me estoy  liando un poco, yo se utilizar el timer2 con pwm pero esto otro me pierdo un poco.

Gracias por la ayuda
Más códigos y desarrollos en https://electronicadicto.wordpress.com/ date una vuelta y curiosea un rato...

Desconectado Thulsa Doom

  • PIC24F
  • *****
  • Mensajes: 771
    • https://electronicadicto.wordpress.com/
Re: Problema con desestabilización de los timer´s
« Respuesta #13 en: 12 de Enero de 2012, 16:23:23 »
Hola de nuevo, pues he conseguido dejarlo como yo quería, he podido cargar el valor del puerto en una variable, para ello he tenido que configurar el puerto con
Código: [Seleccionar]
#BYTE TRIA = 0x85
#BYTE PORTA = 0x05
en el main indicar que es un puerto solo de salida.
Código: [Seleccionar]
TRISA = 0x00; y luego en el bucle de conteo solo he puesto
Código: [Seleccionar]
PORTA = variable;donde variable es por ejemplo 0b000001
 y va perfecto,
para poder poner dos salidas diferentes en el mismo puerto he hecho una AND  de esta manera
Código: [Seleccionar]
PORTA = (variable1 & 0b010011)+variable2); y va a la perfección
lo que me falta es estudiar la manera de integrar TIMER1 y CCP a ver si me sale.
saludos y gracias por la ayuda
Más códigos y desarrollos en https://electronicadicto.wordpress.com/ date una vuelta y curiosea un rato...