Autor Tema: generar retardos de tiempo real  (Leído 11264 veces)

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

Desconectado self08

  • PIC10
  • *
  • Mensajes: 5
generar retardos de tiempo real
« en: 05 de Noviembre de 2009, 08:15:21 »
Qué se puede usar para generar intervalos de tiempos exactos, por ej 1 seg?

Desconectado scientist

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 999
Re: generar retardos de tiempo real
« Respuesta #1 en: 05 de Noviembre de 2009, 11:51:32 »
que microcontrolador estas utilizando, la nueva gama ya viene con un RTC asi que con solo ponerle un cristal de 32.xx Khz va de maravilla (no me acuerdo ahora mismo el valor del cristal) y si no tienes esa opcion, en processor expert, hay una funcion en donde puedes generar delays de una buena exactitud, solo tienes que irte a CPU y activarlos, saludos
NO le digas a DIOS que tienes un gran problema, dile a tu problema que tienes un GRAN DIOS!!
Alma mia y castillo mio, mi Dios en quien yo confiare....

Desconectado edusito

  • PIC10
  • *
  • Mensajes: 14
Re: generar retardos de tiempo real
« Respuesta #2 en: 05 de Enero de 2012, 13:31:34 »
Hola

Estoy en el mismo dilema, pero nunca he utilizado el processor expert, podrias indicarme como hacerlo?? o quizas algun link donde exista un ejemplo de estos intervalos??

Gracias y Saludos

Desconectado RICHI777

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1498
Re: generar retardos de tiempo real
« Respuesta #3 en: 04 de Febrero de 2012, 18:52:44 »
Hola, creo que comente el tema de usar el Proccess Expert en otro post, pero la idea es la sgte. Si bien el Proccess Expert es una Herramienta que permite generar y generenciar proyectos yo la utilizo como herramienta alternativa cuando necesito generar código para un periferico específico. Una de las cosas buenas que tiene esta utilidad es que permite generar código para crear un delay especifico sin usar timer ni otros recursos. Para poder realizar esto es necesario configurar exactamente los valores de clock que va utilizar el micro ( Xtal, reloj interno, prescaler, etc, etc ) una vez hecho generas el código y te a aparecer una función asi:

Código: C
  1. void Cpu_Delay100US( word us100 )
  2. {
  3.   /* Total irremovable overhead: 16 cycles */
  4.   /* ldhx: 5 cycles overhead (load parameter into register) */
  5.   /* jsr:  5 cycles overhead (jump to subroutine) */
  6.   /* rts:  6 cycles overhead (return from subroutine) */
  7.  
  8.   /* aproximate irremovable overhead for each 100us cycle (counted) : 8 cycles */
  9.   /* aix:  2 cycles overhead  */
  10.   /* cphx: 3 cycles overhead  */
  11.   /* bne:  3 cycles overhead  */
  12.   asm {
  13. loop:
  14.     /* 100 us delay block begin */
  15.     psha                               /* (2 c) backup A */
  16.     /*
  17.      * Delay
  18.      *   - requested                  : 100 us @ 8MHz,
  19.      *   - possible                   : 800 c, 100000 ns
  20.      *   - without removable overhead : 788 c, 98500 ns
  21.      */
  22.     pshh                               /* (2 c: 250 ns) backup H */
  23.     pshx                               /* (2 c: 250 ns) backup X */
  24.     ldhx #$0026                        /* (3 c: 375 ns) number of iterations */
  25. label0:
  26.     LDA #85                            /* Reset watchdog counter - 2x write*/
  27.     STA SRS
  28.     LDA #170
  29.     STA SRS
  30.     aix #-1                            /* (2 c: 250 ns) decrement H:X */
  31.     cphx #0                            /* (3 c: 375 ns) compare it to zero */
  32.     bne label0                         /* (3 c: 375 ns) repeat 38x */
  33.     pulx                               /* (3 c: 375 ns) restore X */
  34.     pulh                               /* (3 c: 375 ns) restore H */
  35.     nop                                /* (1 c: 125 ns) wait for 1 c */
  36.     nop                                /* (1 c: 125 ns) wait for 1 c */
  37.     nop                                /* (1 c: 125 ns) wait for 1 c */
  38.     nop                                /* (1 c: 125 ns) wait for 1 c */
  39.     nop                                /* (1 c: 125 ns) wait for 1 c */
  40.     nop                                /* (1 c: 125 ns) wait for 1 c */
  41.     nop                                /* (1 c: 125 ns) wait for 1 c */
  42.     nop                                /* (1 c: 125 ns) wait for 1 c */
  43.     nop                                /* (1 c: 125 ns) wait for 1 c */
  44.     nop                                /* (1 c: 125 ns) wait for 1 c */
  45.     nop                                /* (1 c: 125 ns) wait for 1 c */
  46.     nop                                /* (1 c: 125 ns) wait for 1 c */
  47.     nop                                /* (1 c: 125 ns) wait for 1 c */
  48.     nop                                /* (1 c: 125 ns) wait for 1 c */
  49.     nop                                /* (1 c: 125 ns) wait for 1 c */
  50.     pula                               /* (2 c) restore A */
  51.     /* 100 us delay block end */
  52.     aix #-1                            /* us100 parameter is passed via H:X registers */
  53.     cphx #0
  54.     bne loop                           /* next loop */
  55.     rts                                /* return from subroutine */
  56.   }
  57. }


Lo bueno de esta función es que va a ajustar automaticamente cuando cambies los valores del clock, lo que hace es calcular el retardo de 100 us en base al ciclo de instrucción con que trabaje el proyecto.

Saludos !
« Última modificación: 04 de Febrero de 2012, 18:54:58 por RICHI777 »

Desconectado cicloide2

  • PIC18
  • ****
  • Mensajes: 359
Re: generar retardos de tiempo real
« Respuesta #4 en: 25 de Mayo de 2012, 13:13:57 »
Esto esta buenisimo RICHI777, pero como se configura  en el Proces Expert?
Cuales son los pasos a seguir? espero no estar abusando de tu paciencia?

De casualidad vi el tema y lo lei (recien ahora) me hubiera venido bien para la practica que hice (con el tema de los antirebotes).

Saludos  :mrgreen: :-/ :mrgreen:

Desconectado RICHI777

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1498
Re: generar retardos de tiempo real
« Respuesta #5 en: 25 de Mayo de 2012, 19:37:42 »
Hola, es imposible por aquí hacer un tutorial del Proccess Expert, pero en la web de FreeScale seguro que hay algún documento. Lamento no poder ayudarte.

Saludos !

PD. Si estas en Argentina y en Buenos Aires tal vez por teléfono podría ayudarte.

Desconectado juanml

  • PIC10
  • *
  • Mensajes: 30
Re: generar retardos de tiempo real
« Respuesta #6 en: 25 de Mayo de 2012, 22:51:19 »
Es muy fácil! Espero que con estas imágenes puedas hacerlo.
Después de elegir el Processor Expert cuando creaste el protecto, vas hasta "ProcessorExpert.pe>Cpus" y hacés doble click en el archivo que esta adentro.



Después vas a "Methods" en el "Component Inspector" y en "Delay100US" ponés "generate code".



Ahora solamente tenés que generar al código como muestra la siguiente imagen.



En la carpeta "Generated_Code" abrí el archivo Cpu.c y ahí va a estar el código generado.



El retardo lo va a generar de acuerdo a la configuración de reloj.


Tambíen lo podés hacer vos usando código en assembler teniendo en cuenta los ciclos de reloj que consume cada instrucción.

Desconectado cicloide2

  • PIC18
  • ****
  • Mensajes: 359
Re: generar retardos de tiempo real
« Respuesta #7 en: 26 de Mayo de 2012, 11:29:16 »
Gracias RICHI777 (te envie un MP).
Gracias Juanml, exelente precentacion, seria de la misma manera para el CW_v6.3? (es la que estoy utilizando) con esl BDM de Edudevices R(S) POD.

Desconectado RICHI777

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1498
Re: generar retardos de tiempo real
« Respuesta #8 en: 26 de Mayo de 2012, 12:44:24 »
Hola cicloide2 el amigo Juanml te dejo una excelente referencia de como hacerlo !

Saludos !


Desconectado cicloide2

  • PIC18
  • ****
  • Mensajes: 359
Re: generar retardos de tiempo real
« Respuesta #9 en: 26 de Mayo de 2012, 13:12:52 »
Bueno Juanml, lo probe y logre hacer lo que tu haces con el CW10 en el CW6.3.
Supon que lo que quiero hacer es lo que dice RICHI777, utilizar el Proces Expert solo para genera subrrutinas, en este caso  una subrrutina de Delay de 100 microsegundos aca abajo coloco lo que genero el PE:

Código: C
  1. /** ###################################################################
  2. **     THIS COMPONENT MODULE IS GENERATED BY THE TOOL. DO NOT MODIFY IT.
  3. **     Filename  : Cpu.C
  4. **     Project   : delay_con_PE
  5. **     Processor : MC9S08SH8CPJ
  6. **     Component : MC9S08SH8_20
  7. **     Version   : Component 01.007, Driver 01.35, CPU db: 3.00.062
  8. **     Datasheet : MC9S08SH8 Rev. 3 6/2008
  9. **     Compiler  : CodeWarrior HCS08 C Compiler
  10. **     Date/Time : 26/05/2012, 12:43 p.m.
  11. **     Abstract  :
  12. **         This bean "MC9S08SH8_20" contains initialization of the
  13. **         CPU and provides basic methods and events for CPU core
  14. **         settings.
  15. **     Settings  :
  16. **
  17. **     Contents  :
  18. **         EnableInt  - void Cpu_EnableInt(void);
  19. **         DisableInt - void Cpu_DisableInt(void);
  20. **         Delay100US - void Cpu_Delay100US(word us100);
  21. **
  22. **     Copyright : 1997 - 2009 Freescale Semiconductor, Inc. All Rights Reserved.
  23. **    
  24. **     http      : www.freescale.com
  25. **     mail      : support@freescale.com
  26. ** ###################################################################*/
  27.  
  28. /* MODULE Cpu. */
  29.  
  30. #pragma MESSAGE DISABLE C4002 /* WARNING C4002: Result not used is ignored */
  31.  
  32. #include "PE_Types.h"
  33. #include "PE_Error.h"
  34. #include "PE_Const.h"
  35. #include "IO_Map.h"
  36. #include "Events.h"
  37. #include "Cpu.h"
  38.  
  39.  
  40. /* Global variables */
  41. volatile byte CCR_reg;                 /* Current CCR register */
  42.  
  43.  
  44. /*
  45. ** ===================================================================
  46. **     Method      :  Cpu_Interrupt (component MC9S08SH8_20)
  47. **
  48. **     Description :
  49. **         The method services unhandled interrupt vectors.
  50. **         This method is internal. It is used by Processor Expert only.
  51. ** ===================================================================
  52. */
  53. ISR(Cpu_Interrupt)
  54. {
  55.   /* This code can be changed using the CPU bean property "Build Options / Unhandled int code" */
  56.   asm(BGND);
  57. }
  58.  
  59.  
  60. /*
  61. ** ===================================================================
  62. **     Method      :  Cpu_DisableInt (component MC9S08SH8_20)
  63. **
  64. **     Description :
  65. **         Disables maskable interrupts
  66. **     Parameters  : None
  67. **     Returns     : Nothing
  68. ** ===================================================================
  69. */
  70. /*
  71. void Cpu_DisableInt(void)
  72.  
  73. **      This method is implemented as macro in the header module. **
  74. */
  75.  
  76. /*
  77. ** ===================================================================
  78. **     Method      :  Cpu_EnableInt (component MC9S08SH8_20)
  79. **
  80. **     Description :
  81. **         Enables maskable interrupts
  82. **     Parameters  : None
  83. **     Returns     : Nothing
  84. ** ===================================================================
  85. */
  86. /*
  87. void Cpu_EnableInt(void)
  88.  
  89. **      This method is implemented as macro in the header module. **
  90. */
  91.  
  92. /*
  93. ** ===================================================================
  94. **     Method      :  Cpu_Delay100US (component MC9S08SH8_20)
  95. **
  96. **     Description :
  97. **         This method realizes software delay. The length of delay
  98. **         is at least 100 microsecond multiply input parameter
  99. **         [us100]. As the delay implementation is not based on real
  100. **         clock, the delay time may be increased by interrupt
  101. **         service routines processed during the delay. The method
  102. **         is independent on selected speed mode.
  103. **     Parameters  :
  104. **         NAME            - DESCRIPTION
  105. **         us100           - Number of 100 us delay repetitions.
  106. **     Returns     : Nothing
  107. ** ===================================================================
  108. */
  109. #pragma NO_ENTRY
  110. #pragma NO_EXIT
  111. #pragma MESSAGE DISABLE C5703
  112. void Cpu_Delay100US(word us100)
  113. {
  114.  
  115.   asm {
  116. loop:
  117.    
  118.     pshh                              
  119.     pshx                               /* (2 c: 250 ns) backup X */
  120.     ldhx #$0061                        /* (3 c: 375 ns) number of iterations */
  121. label0:
  122.     aix #-1                            /* (2 c: 250 ns) decrement H:X */
  123.     cphx #0                            /* (3 c: 375 ns) compare it to zero */
  124.     bne label0                         /* (3 c: 375 ns) repeat 97x */
  125.     pulx                               /* (3 c: 375 ns) restore X */
  126.     pulh                               /* (3 c: 375 ns) restore H */
  127.     nop                                /* (1 c: 125 ns) wait for 1 c */
  128.     nop                                /* (1 c: 125 ns) wait for 1 c */
  129.     nop                                /* (1 c: 125 ns) wait for 1 c */
  130.     /* 100 us delay block end */
  131.     aix #-1                            /* us100 parameter is passed via H:X registers */
  132.     cphx #0
  133.     bne loop                           /* next loop */
  134.     rts                                /* return from subroutine */
  135.   }
  136.   /* Restore MISRA rule 19 checking - Octal constant used */
  137.   /*lint +esym( 960, 19)   */
  138.   /* Restore MISRA rule 55 checking - Non-case label used */
  139.   /*lint +esym( 961, 55)   */
  140. }
  141.  
  142. /*
  143. ** ===================================================================
  144. **     Method      :  _EntryPoint (component MC9S08SH8_20)
  145. **
  146. **     Description :
  147. **         Initializes the whole system like timing and so on. At the end
  148. **         of this function, the C startup is invoked to initialize stack,
  149. **         memory areas and so on.
  150. **         This method is internal. It is used by Processor Expert only.
  151. ** ===================================================================
  152. */
  153. extern void _Startup(void);            /* Forward declaration of external startup function declared in file Start12.c */
  154.  
  155. #pragma NO_FRAME
  156. #pragma NO_EXIT
  157. void _EntryPoint(void)
  158. {
  159.   /* ### MC9S08SH8_20 "Cpu" init code ... */
  160.   /*  PE initialization code after reset */
  161.  
  162.   /* Common initialization of the write once registers */
  163.   /* SOPT1: COPT=0,STOPE=0,??=0,??=0,IICPS=0,BKGDPE=1,RSTPE=0 */
  164.   setReg8(SOPT1, 0x02);                
  165.   /* SPMSC1: LVWF=0,LVWACK=0,LVWIE=0,LVDRE=1,LVDSE=1,LVDE=1,??=0,BGBE=0 */
  166.   setReg8(SPMSC1, 0x1C);                
  167.   /* SPMSC2: ??=0,??=0,LVDV=0,LVWV=0,PPDF=0,PPDACK=0,??=0,PPDC=0 */
  168.   setReg8(SPMSC2, 0x00);                
  169.   /*  System clock initialization */
  170.   if (*(unsigned char*)0xFFAF != 0xFF) { /* Test if the device trim value is stored on the specified address */
  171.     ICSTRM = *(unsigned char*)0xFFAF;  /* Initialize ICSTRM register from a non volatile memory */
  172.     ICSSC = *(unsigned char*)0xFFAE;   /* Initialize ICSSC register from a non volatile memory */
  173.   }
  174.   /* ICSC1: CLKS=0,RDIV=0,IREFS=1,IRCLKEN=1,IREFSTEN=0 */
  175.   setReg8(ICSC1, 0x06);                /* Initialization of the ICS control register 1 */
  176.   /* ICSC2: BDIV=1,RANGE=0,HGO=0,LP=0,EREFS=0,ERCLKEN=0,EREFSTEN=0 */
  177.   setReg8(ICSC2, 0x40);                /* Initialization of the ICS control register 2 */
  178.   while(!ICSSC_IREFST) {               /* Wait until the source of reference clock is internal clock */
  179.   }
  180.   /* GNGC: GNGPS7=0,GNGPS6=0,GNGPS5=0,GNGPS4=0,GNGPS3=0,GNGPS2=0,GNGPS1=0,GNGEN=0 */
  181.   setReg8(GNGC, 0x00);                  
  182.   /*** End of PE initialization code after reset ***/
  183.   __asm   jmp _Startup ;               /* Jump to C startup code */
  184.  
  185. }
  186.  
  187. /*
  188. ** ===================================================================
  189. **     Method      :  PE_low_level_init (component MC9S08SH8_20)
  190. **
  191. **     Description :
  192. **         Initializes beans and provides common register initialization.
  193. **         The method is called automatically as a part of the
  194. **         application initialization code.
  195. **         This method is internal. It is used by Processor Expert only.
  196. ** ===================================================================
  197. */
  198. void PE_low_level_init(void)
  199. {
  200.   /* Common initialization of the CPU registers */
  201.   /* PTASE: PTASE4=0,PTASE3=0,PTASE2=0,PTASE1=0,PTASE0=0 */
  202.   clrReg8Bits(PTASE, 0x1F);            
  203.   /* PTBSE: PTBSE7=0,PTBSE6=0,PTBSE5=0,PTBSE4=0,PTBSE3=0,PTBSE2=0,PTBSE1=0,PTBSE0=0 */
  204.   setReg8(PTBSE, 0x00);                
  205.   /* PTCSE: PTCSE3=0,PTCSE2=0,PTCSE1=0,PTCSE0=0 */
  206.   clrReg8Bits(PTCSE, 0x0F);            
  207.   /* PTADS: ??=0,??=0,??=0,PTADS4=1,PTADS3=1,PTADS2=1,PTADS1=1,PTADS0=1 */
  208.   setReg8(PTADS, 0x1F);                
  209.   /* PTBDS: PTBDS7=1,PTBDS6=1,PTBDS5=1,PTBDS4=1,PTBDS3=1,PTBDS2=1,PTBDS1=1,PTBDS0=1 */
  210.   setReg8(PTBDS, 0xFF);                
  211.   /* PTCDS: ??=0,??=0,??=0,??=0,PTCDS3=1,PTCDS2=1,PTCDS1=1,PTCDS0=1 */
  212.   setReg8(PTCDS, 0x0F);                
  213.   /* ### Shared modules init code ... */
  214.   __EI();                              /* Enable interrupts */
  215. }
  216.  
  217. /* Initialization of the CPU registers in FLASH */
  218.  
  219. /* NVPROT: FPS7=1,FPS6=1,FPS5=1,FPS4=1,FPS3=1,FPS2=1,FPS1=1,FPDIS=1 */
  220. const unsigned char NVPROT_INIT @0x0000FFBD = 0xFF;
  221.  
  222. /* NVOPT: KEYEN=0,FNORED=1,??=1,??=1,??=1,??=1,SEC01=1,SEC00=0 */
  223. const unsigned char NVOPT_INIT @0x0000FFBF = 0x7E;
  224.  
  225. /* END Cpu. */
  226.  
  227. /*
  228. ** ###################################################################
  229. **
  230. **     This file was created by Processor Expert 3.07 [04.34]
  231. **     for the Freescale HCS08 series of microcontrollers.
  232. **
  233. ** ###################################################################
  234. */

En este caso en particular si yo solo quiero la rutina de delay solo debo cortar esta parte y pegarla en mi pryecto?

Código: C
  1. void Cpu_Delay100US(word us100)
  2. {
  3.  
  4.   asm {
  5. loop:
  6.    
  7.     pshh                              
  8.     pshx                               /* (2 c: 250 ns) backup X */
  9.     ldhx #$0061                        /* (3 c: 375 ns) number of iterations */
  10. label0:
  11.     aix #-1                            /* (2 c: 250 ns) decrement H:X */
  12.     cphx #0                            /* (3 c: 375 ns) compare it to zero */
  13.     bne label0                         /* (3 c: 375 ns) repeat 97x */
  14.     pulx                               /* (3 c: 375 ns) restore X */
  15.     pulh                               /* (3 c: 375 ns) restore H */
  16.     nop                                /* (1 c: 125 ns) wait for 1 c */
  17.     nop                                /* (1 c: 125 ns) wait for 1 c */
  18.     nop                                /* (1 c: 125 ns) wait for 1 c */
  19.     /* 100 us delay block end */
  20.     aix #-1                            /* us100 parameter is passed via H:X registers */
  21.     cphx #0
  22.     bne loop                           /* next loop */
  23.     rts                                /* return from subroutine */
  24.   }
  25.   /* Restore MISRA rule 19 checking - Octal constant used */
  26.   /*lint +esym( 960, 19)   */
  27.   /* Restore MISRA rule 55 checking - Non-case label used */
  28.   /*lint +esym( 961, 55)   */
  29. }

Otra pregunta si quisiera gnerar rutinas de otro tiempos, menores por ejemplo,  con el PE seria posible? y en caso de tiempos mayores  tenderia que invocar esta funcion y colocarla dentro de una rapeticion (estamos hablando de no utilizar los TIM no,con los  cuales todabia no hice nada, mas que leer documentos )

Gracias :mrgreen:
« Última modificación: 26 de Mayo de 2012, 13:17:49 por cicloide2 »

Desconectado RICHI777

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1498
Re: generar retardos de tiempo real
« Respuesta #10 en: 26 de Mayo de 2012, 13:35:49 »
Hola, el PE no permite generar rutinas en otros tiempos, si lo que deseas es un tiempo mayor y el número es múltiplo entonces podes hacer lo que comentas de las repeticiones.Para tiempos menores no se puede. También tene en cuenta que esta rutina no es 100 % precisa ya que si mientras se esta ejecutando la misma una interrupción aparece, el tiempo se desvirtua. Para rutinas sumamente precisas necesitas usar un timer. Si buscas en este sub foro había un link donde se podía descargar un libro sobre toda la familia HCs08 y el lenguaje C.

Saludos !

Desconectado mauricio2346

  • PIC10
  • *
  • Mensajes: 7
Re: generar retardos de tiempo real
« Respuesta #11 en: 14 de Junio de 2012, 23:55:18 »
Hola, el PE no permite generar rutinas en otros tiempos, si lo que deseas es un tiempo mayor y el número es múltiplo entonces podes hacer lo que comentas de las repeticiones.Para tiempos menores no se puede. También tene en cuenta que esta rutina no es 100 % precisa ya que si mientras se esta ejecutando la misma una interrupción aparece, el tiempo se desvirtua. Para rutinas sumamente precisas necesitas usar un timer. Si buscas en este sub foro había un link donde se podía descargar un libro sobre toda la familia HCs08 y el lenguaje C.

Saludos !

generar una interrupcion con el RTC es muyy facil.  no necesita el reloj de 32...Khz, con el reloj de bus interno basta, a menos que se quieran bases de tiempo muy muy precisas.  yo he generado retardos por RTC de un segundo y mucho menos con reloj de 12Mhz y bus de 24Mhz.

aca la rutina:

Código: [Seleccionar]
void RTC_Init(void){
  RTCSC=0X1B;   //Baja Bandera de Interrupcion por RTC, selecciona reloj Interno 1KHz, habilita interrupcion RTIE, preescaler RTCPS=10mS.
  RTCMOD=0x64;  //Modulo de disparo de interrupción cada 100 ciclos (0X64) o 10mS*100=1 Segundo.
}

void main (void){
RTC_Init();

for(;;){
if(RTC_Flag){
      RTC_Flag=0;
      State_Led=~State_Led;
         }


}
}




#pragma TRAP_PROC
void RTC_ISR(void) {
RTCSC;             // Reconoce la interrupcion
  RTCSC_RTIF=1;      //Baja Bandera de Interrupcion
  RTC_Flag=1;
}



este codigo hace toggle sobre un led cada segundo.

es un codigo bastante simple, ahora, podría meterse en un vector todos los preescaler ( posibles valores del registro RTCSC segun datasheet).  recuerde que el modulo (RTCMOD) se usa igual a los timers. en mi caso, un modulo de 100, así que cada 100 preescaler tengo un disparo.  aunque la rutina se hace por interrpciones, se ejecuta con una bandera.  un programa no debería tener mucho codigo en las interrupciones, ya que en caso de quedarse colgado en la interupcion, el perro guardian podría empezar a morder jajaja.     

está escrito en Codewarrior 6.3. puede hacerse en processor expert, pero prefiero escribir yo mismo la rutina, ya que así entiendo el funcionamiento del modulo, y consume menos memoria.






Desconectado cicloide2

  • PIC18
  • ****
  • Mensajes: 359
Re: generar retardos de tiempo real
« Respuesta #12 en: 17 de Junio de 2012, 21:03:47 »
Una buena alternativa, que opinas RICHI777, yo estoy trando de entenderla  :) todabia.(teniendo en cuenta,  que ambos coincidieron en que , los multiplos del codigo que genera Proces Expert para 100 ms y la  opcion que propone  self08, se desbirtua si se llama a una subrrutina, y es por eso que es conveniente utilisar los TIM para generar tiempos precisos (cosa que todabia no se hacer ) y estos no modificaran su curso ante una interrupcion no? corrijanme?

Salñudos ispanosparlante :mrgreen: :-/ :mrgreen: :-/

Desconectado mauricio2346

  • PIC10
  • *
  • Mensajes: 7
Re: generar retardos de tiempo real
« Respuesta #13 en: 18 de Junio de 2012, 01:00:43 »
Una buena alternativa, que opinas RICHI777, yo estoy trando de entenderla  :) todabia.(teniendo en cuenta,  que ambos coincidieron en que , los multiplos del codigo que genera Proces Expert para 100 ms y la  opcion que propone  self08, se desbirtua si se llama a una subrrutina, y es por eso que es conveniente utilisar los TIM para generar tiempos precisos (cosa que todabia no se hacer ) y estos no modificaran su curso ante una interrupcion no? corrijanme?

Salñudos ispanosparlante :mrgreen: :-/ :mrgreen: :-/

es 100% imposible lograr precisiones altísimas con un modulo, ya sea timer o RTC.  es porque el micro consume tiempo de maquina mientras detecta la interrupcion, la ejecuta y deshabilita, además de las acciones que pueden darse sobre pines, modulos, etc.   yo logré generar con el modulo timer una señal analoga con PWM a 10Khz, y una desviación diría que de un 1% a 1.5%, lo que a mi parecer, es insignificante.   

lo que puede hacer es utilizar el simulador para determinar cuantos ciclos de maquina o tiempo toma entrar a la interrupcion, y ejecutar la tarea luego de la interrupcion.  luego, restar al modulo del timer o RTC el valor de este tiempo y así se ejecutan las cosas de forma muy precisa.  en mi ejemplo, simplemente leo una bandera en el ciclo infinito, cuando hay una interrupcion de timer la bandera cambia de valor, y hage toggle sobre el led.  luego, se borra la bandera y el proceso se repite.  todo lo que este dentro del IF sería lo que se ejecuta periodicamente, por ejemplo, el muestreo de una tarjeta de adquisicion de datos. 
no es recomendable ejecutar nada dentro de la interrupción, ya que si se queda pegado en la interrupcion es posible que el watchdog timer se dispare y el micro se resetee, además, una regla de oro en Freescale o cualquier mico es: "nunca abandone el for".

lo que dice RICHI777 de multiples interrupciones es verdad, solo que uno puede "lidiar con eso", teniendo en cuenta la prioridad que tienen en el vector de interrupciones, siendo las de menor orden, o valor, o numero, las de mayor prioridad.  por ejemplo con un timer, lo unico que cambia en la interrupcion es el valor de un registro por ejemplo si quiero variar el duty (moduo del timer).  si es el modulo serial, solo es cargar un dato al buffer de salida y bajar una bandera.. en fin..


esta rutina de RTC la tengo funcionando de maravilla para capturar datos en una uSD de 2Gb, cada 50ms, espero la entienda, ya sabe que cualquier duda, yo o cualquier otro forero tendrá respuestas!
 
Saludos
« Última modificación: 18 de Junio de 2012, 01:10:56 por mauricio2346 »

Desconectado RICHI777

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1498
Re: generar retardos de tiempo real
« Respuesta #14 en: 18 de Junio de 2012, 12:04:31 »
Hola Mauricio,

Citar
una regla de oro en Freescale o cualquier mico es: "nunca abandone el for"

No entendí bien esta parte, podrías ser mas específico, gracias !

Saludos !