Autor Tema: Depuración software de retraso de trigger en CCS  (Leído 2117 veces)

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

Desconectado freshdesing

  • Colaborador
  • PIC12
  • *****
  • Mensajes: 88
Depuración software de retraso de trigger en CCS
« en: 05 de Mayo de 2010, 07:26:11 »
Hola, he realizado el siguiente programa, que en su cabecera se explica el funcionamiento, y a la hora de hacer el retraso de un trigger externo, mediante RB0, la función delay_ms() del CCS, no da los retrasos bien, por lo que he tenido que modificar cada retraso de forma manual. Mi idea sería, una vez calculado el tiempo que tarda en ejecutarse la rutina, pues sumarle le retraso que quieres. Pero según el tiempo del delay varia mucho... Os adjunto el programa.


long tiempo_us_lcd[9]={100,200,300,400,500,600,700,800,900}; //vector us lcd
long tiempo_us[9]={40,140,240,330,430,520,620,720,810}; //vector us para tiempo

long tiempo_ms_lcd[9]={10,15,20,25,30,35,40,45,50}; //vector ms *10 para lcd
long tiempo_ms[9]={850,1350,1810,2300,2800,3250,3750,4210,4750}; //vector ms para tiempo

En estas líneas anterioers, se puede ver como uso un tiempo para mostrar por el lcd, y seguidamente, el tiempo real que tengo que usar en la función delay para que sea el tiempo exacto.


Código: C
  1. ////////////////////////////////////////////////////////////////////////////////
  2. //                     Trigger Delay  0.1 us a 5 ms
  3. //                  Abril 2010
  4. // Realizado:  Jose Antonio
  5. // Programa:   Delay Trigger 0.1 us a 5 ms
  6. // Proyecto:   201004JMR02
  7. //
  8. // -Versión: 1.0   Abril 2010
  9. //    
  10. //
  11. //   Dispositivo: PIC 16F876         Compilador:    CCS vs4.049
  12. //
  13. //    FUNCIONAMIENTO:
  14. //       A PARTIR DE UN TRIGGER EXTERNO, POR FLANCO DE SUBIDA (RB0), SE
  15. //    GENERA UN TRIGGER EXTERNO (RB1) DE UNA DURACIÓN DE 100 uS. CON UN RETRASO
  16. //    COMPRENDIDO ENTRE 100 uS Y 5 mS. ESTE RETRASO SE SELECCIONA A TRAVÉS DE
  17. //    UN LCD Y 4 BOTONES, DOS DE SELECCION DE uS O mS, Y OTROS DOS PARA
  18. //    AUMENTAR O DISMINUIR EL TIEMPO. LOS TIEMPOS PREFIJADOS SON:
  19. //    uS: 100,200,300,400,500,600,700,800 Y 900.
  20. //    mS: 1,1.5,2,2.5,3,3.5,4,4.5 Y 5.
  21. //       SE GUARDA EN LA EEPROM LA CONFIGURACION DE TIEMPO
  22. //    TANTO DE US COMO DE mS
  23. //
  24. //    
  25. //
  26. //       -Posibles Mejoras: Guardar la última configuración en la memoria
  27. //          del PIC.
  28. //    
  29. //    RB0   -->   IN TRIGER EXTERNO (POR FLANCO DE SUBIDA)
  30. //    RB1   -->   OUT TRIGGER RETRASADO
  31. //    RB2   -->  
  32. //    RB3   -->   OUT LED STATUS
  33. //    RB7   -->   IN INCREMENTAR +
  34. //    RB6   -->   IN DECREMENTAR -
  35. //    RB5   -->   IN SELECCION uS
  36. //    RB4   -->   IN SELECCION mS
  37. //    
  38. //
  39. //
  40. //       Conexiones del LCD 16x2 4 bits PORTC
  41. //    RC0   -->   OUT E
  42. //    RC1   -->   OUT RS
  43. //    RC2   -->   OUT RW
  44. //    RC3   -->  
  45. //    RC4   -->   OUT D4
  46. //    RC5   -->   OUT D5              
  47. //    RC6   -->   OUT D6
  48. //    RC7   -->   OUT D7
  49. //  
  50. //
  51. ////////////////////////////////////////////////////////////////////////////////
  52.  
  53. #include <16f876A.h>            //pic a utilizar
  54.  
  55.  
  56. #fuses XT,NOWDT,NOPROTECT,PUT,NOLVP,NOBROWNOUT    //ordenes para el programador
  57. #use delay(clock=4000000,RESTART_WDT)   //Fosc=4Mhz
  58. #include<lcd_C.c>                       //libreria manejo LCD 16x2 4 bits PORTC
  59.  
  60. #use fast_io(A)
  61. #use fast_io(B)
  62. //#use fast_io(C)
  63.  
  64. #byte port_a = 0x05
  65. #byte port_b = 0x06
  66. #byte port_c = 0x07
  67.  
  68.  
  69. //256 x 8 bytes of EEPROM
  70. #DEFINE MEM_uS 0  //Definimos posiciones de memoria de la eeprom interna
  71. #DEFINE MEM_mS 1
  72. #DEFINE MEM_unit 2
  73.  
  74.  
  75.  
  76.  
  77. //variables globales
  78.  
  79. long tiempo_us_lcd[9]={100,200,300,400,500,600,700,800,900}; //vector us lcd
  80. long tiempo_us[9]={40,140,240,330,430,520,620,720,810}; //vector us para tiempo
  81.  
  82. long tiempo_ms_lcd[9]={10,15,20,25,30,35,40,45,50}; //vector ms *10 para lcd
  83. long tiempo_ms[9]={850,1350,1810,2300,2800,3250,3750,4210,4750}; //vector ms
  84.                                                          // en us para tiempo
  85. int unidades=0;   //0->us  1->ms
  86.  
  87. int i_us=0; //indice para us
  88. int i_ms=0; //indice para ms
  89.  
  90. long TIME_DELAY;    // tiempo para la func. delay. 100 us
  91.  
  92. int flag_disp=1; //Flag para actualizar el display
  93.  
  94.  
  95.  
  96. //Subrutina para refrescar el display
  97. void display (void)
  98.    {
  99.    switch (unidades)
  100.          {
  101.  
  102.        case 0: printf(lcd_putc,"\f");
  103.                printf(lcd_putc,"Time Delay \n");
  104.                printf(lcd_putc,"Delay of %Lu us",tiempo_us_lcd[i_us]);
  105.                flag_disp=1;
  106.                break;
  107.    
  108.        case 1: printf(lcd_putc,"\f");
  109.                printf(lcd_putc,"Time Delay \n");
  110.                printf(lcd_putc,"Delay of %2.1w ms",tiempo_ms_lcd[i_ms]);
  111.                flag_disp=1;
  112.                break;
  113.                
  114.        default:   break;
  115.          }
  116.   }
  117.  
  118.  
  119.  
  120.  
  121. //Subrutina de interrución del TMR1 Cada 0.5 segundos.
  122. //fos/4=frec del TMR1  -> 0-65535
  123. //0,5 seg=(4/Fosc)*8*(65536-valorTMR1)
  124. //TMR 62500 -> 3036
  125. #INT_TIMER1
  126. void control_timer1(void)
  127.    {
  128.    output_bit(pin_b3,!input(pin_b3));
  129.    set_timer1(3036);
  130.    }
  131.  
  132.  
  133.  
  134. #INT_RB
  135. void interrup_RB(void)
  136. {
  137.  delay_ms(100);  //pulsado->>> 1
  138.    if(input(pin_b7)==1)//INCREMENTAR +    
  139.       {
  140.       if (unidades==0)   //Estamos en us
  141.          {
  142.          if (i_us>=8)
  143.             {
  144.             i_us=8;
  145.             }
  146.          else
  147.             {
  148.             i_us=i_us+1;
  149.             }
  150.          TIME_DELAY=tiempo_us[i_us];
  151.          write_eeprom(MEM_uS,i_us);
  152.          }
  153.       else   //Estamos en ms
  154.          {
  155.          if (i_ms>=8)
  156.             {
  157.             i_ms=8;
  158.             }
  159.          else
  160.             {
  161.             i_ms=i_ms+1;
  162.             }
  163.          TIME_DELAY=tiempo_ms[i_ms];
  164.          write_eeprom(MEM_mS,i_ms);
  165.          }
  166.       flag_disp=1;  
  167.       }
  168.      
  169.    
  170.    if(input(pin_b6)==1)//DECREMENTAR -
  171.       {
  172.       if (unidades==0)   //Estamos en us
  173.          {
  174.          if ((i_us<=0)||(i_us>8))
  175.             {
  176.             i_us=0;
  177.             }
  178.          else
  179.             {
  180.             i_us=i_us-1;
  181.             }
  182.          TIME_DELAY=tiempo_us[i_us];
  183.          write_eeprom(MEM_uS,i_us);
  184.          }
  185.       else   //Estamos en ms
  186.          {
  187.          if ((i_ms<=0)||(i_ms>8))
  188.             {
  189.             i_ms=0;
  190.             }
  191.          else
  192.             {
  193.             i_ms=i_ms-1;
  194.             }
  195.          TIME_DELAY=tiempo_ms[i_ms];
  196.          write_eeprom(MEM_mS,i_ms);
  197.          }
  198.       flag_disp=1;
  199.       }
  200.  
  201.  //Cambiados el b4 y b5, por hard estan bien, pero por soft no funcionaban
  202.  
  203.    if(input(pin_b4)==1)//SELECCION mS
  204.       {
  205.       unidades=1;
  206.       TIME_DELAY=tiempo_ms[i_ms];
  207.       write_eeprom(MEM_unit,unidades);
  208.       flag_disp=1;
  209.       }
  210.  
  211.    if(input(pin_b5)==1)//SELECCION uS
  212.       {
  213.       unidades=0;
  214.       TIME_DELAY=tiempo_us[i_us];
  215.       write_eeprom(MEM_unit,unidades);
  216.       flag_disp=1;
  217.       }
  218.  
  219.    
  220.    
  221. }
  222.  
  223.  
  224.  
  225.  
  226. #INT_EXT
  227. void interrupt_EXT()
  228. {
  229.    delay_us(TIME_DELAY);
  230.    output_bit(pin_b1,1);   //Salida trigger
  231.    delay_us(100);       //duracion del trigger
  232.    output_bit(pin_b1,0);
  233. }
  234.  
  235.  
  236.  
  237. ///PROGRAMA
  238. void main(void)
  239. {
  240.  
  241.    disable_interrupts(GLOBAL);
  242.    set_tris_a(0x00);       //    RA0   -->  
  243.                            //    RA1   -->  
  244.                            //    RA2   -->  
  245.                            //    RA3   -->  
  246.                            //    RA4   -->  
  247.                            //    RA5   -->  
  248.  
  249.    port_b_pullups(false);   // Resistencias de polarización del puerto B
  250.  
  251.    set_tris_b(0xF1);       //    RB7   -->   IN INCREMENTAR +
  252.                            //    RB6   -->   IN DECREMENTAR -
  253.                            //    RB5   -->   IN SELECCION uS
  254.                            //    RB4   -->   IN SELECCION mS
  255.                            //    RB3   -->   OUT LED STATUS
  256.                            //    RB2   -->  
  257.                            //    RB1   -->   OUT TRIGER
  258.                            //    RB0   -->   IN TRIGER EXTERNO
  259.  
  260.                            
  261.    //set_tris_c(0x00);     //    RC0   -->   OUT E
  262.                            //    RC1   -->   OUT RS
  263.                            //    RC2   -->   OUT RW
  264.                            //    RC3   -->  
  265.                            //    RC4   -->   OUT D4
  266.                            //    RC5   -->   OUT D5              
  267.                            //    RC6   -->   OUT D6
  268.                            //    RC7   -->   OUT D7
  269.  
  270.  
  271.    setup_timer_1(T1_INTERNAL|T1_DIV_BY_8);
  272.    enable_interrupts(INT_TIMER1);
  273.    enable_interrupts(INT_RB);
  274.    enable_interrupts(INT_EXT);
  275.    ext_int_edge (L_TO_H);  
  276.    enable_interrupts(GLOBAL);
  277.    
  278.    lcd_init();         //inicializa lcd
  279.      
  280.    i_us=read_eeprom(MEM_uS);
  281.    i_ms=read_eeprom(MEM_mS);
  282.    unidades=read_eeprom(MEM_unit);
  283.    
  284.    if (unidades==0)
  285.       {
  286.       TIME_DELAY=tiempo_us[i_us];   //iniciamos en el valor guardado
  287.       }
  288.       else
  289.       {
  290.       TIME_DELAY=tiempo_ms[i_ms];   //iniciamos en el valor guardado
  291.       }
  292.      
  293.    
  294.    while(1)
  295.       {
  296.      
  297.       if (flag_disp==1)
  298.          {
  299.          display();     //Refrescamos el display
  300.          flag_disp=0;
  301.          }
  302.       }
  303. }
  304.  
  305. [/code=c]
  306.  
  307.  
  308. ¿alguien saber por qué según el tiempo de delay varia el tiempo que tarda en ejecutarse el retraso del pulso?
  309.  
  310. {
  311.    delay_us(TIME_DELAY);
  312.    output_bit(pin_b1,1);   //Salida trigger
  313.    delay_us(100);       //duracion del trigger
  314.    output_bit(pin_b1,0);
  315. }
  316.  
  317. Gracias y un saludo
« Última modificación: 06 de Mayo de 2010, 06:16:29 por freshdesing »

Desconectado bmfranky

  • PIC16
  • ***
  • Mensajes: 165
    • La Tienda De Fran
Re: Depuración software de retraso de trigger en CCS
« Respuesta #1 en: 05 de Mayo de 2010, 09:13:05 »
Creo que es por la forma en que traduce el CCS los bucles de retardo a opcodes en ensamblador. si necesitas que sea tan precisos los retardos, te recomiendo que los codifiques en ensamblador y los incluyas como una librería, así podrás controlar hasta la milésima el retardo, así lo hice yo en un retardo de encendido que implemente hace unos años.
Visiten La Tienda De Fran ;-) Aqui. y mi nueva Web Aqui.

Desconectado freshdesing

  • Colaborador
  • PIC12
  • *****
  • Mensajes: 88
Re: Depuración software de retraso de trigger en CCS
« Respuesta #2 en: 06 de Mayo de 2010, 06:17:49 »
Gracias, voy a probar.


 

anything