« anterior próximo »
Páginas: [1]   Ir Abajo

Autor Tema: Maldita #INT_RB disparandose al principio!!  (Leído 2164 veces)

0 Usuarios y 2 Visitantes están viendo este tema.

Desconectado CarloS_32

  • PIC10
  • *
  • Mensajes: 27
Maldita #INT_RB disparandose al principio!!
« en: 15 de Enero de 2011, 11:58:05 »
Hola..bueno ese es el problema q tengo..la verdad no se como hacer para evitar que se dispare en un primer momento despues de encender la alimentación del pic..alguna sugerencia?.este es mi programa..solo me queda pulir este errror..Gracias

Código: CSS
  1. #include <16f877a.h>
  2. #fuses HS,NOPROTECT,NOWDT,PUT,NOLVP,BROWNOUT
  3. #use delay(clock=20M)
  4. #include <flex_lcd.c>
  5. #byte portb=6
  6. #byte portc=7
  7. #byte portd=8
  8. #use standard_io(b)
  9. #use fast_io(c)
  10. #use fast_io(d)
  11. #define VEL_CRYSTAL 0.000000200
  12.  
  13. boolean flagOK=FALSE,flagDistancia=FALSE,flagVelocidad=FALSE,flagSentido=FALSE;
  14. int punteroDistancia=0,punteroVelocidad=0,punteroSentido=0,interrupciones=0,last_b,lastb=0b11110001,PUNTERO=0,cm=0;
  15. unsigned long PASOS=300,CARGAT1=45000;
  16. float NEW_PASOS=0,TIEMPO=0,PPS=100;
  17.  
  18. void secuencia_PCHorario(void);
  19. void secuencia_PCAntihorario(void);
  20. void resetLCD(void);
  21. void calculo_Velocidad(void);
  22.  
  23. #INT_TIMER1
  24. RSI_tmr1()
  25. {
  26. set_timer1(CARGAT1);
  27. ++PUNTERO;
  28. if (PUNTERO==5)
  29. PUNTERO=0;
  30. --PASOS;
  31.  
  32. }
  33.  
  34. #INT_EXT
  35. RSI_intext()
  36. {
  37. while(!input(PIN_B0))
  38.    {
  39.    if(interrupciones==TRUE)
  40.       {
  41.       resetLCD();
  42.       lcd_putc("Ok!");
  43.       delay_ms(100);
  44.       }
  45.    }
  46.       if(interrupciones==TRUE)
  47.       {
  48.       flagOK=TRUE;
  49.       interrupciones=FALSE;
  50.       resetLCD();
  51.       PASOS=NEW_PASOS;
  52.       printf(lcd_putc,"PASOS=\n%lu",PASOS);
  53.       }
  54.       else if(interrupciones==FALSE)
  55.       {
  56.       flagOK=FALSE;
  57.       flagVelocidad=FALSE;
  58.       flagDistancia=FALSE;
  59.       flagSentido=FALSE;
  60.       }
  61. }
  62.  
  63. #INT_RB
  64. RSI_rb()
  65. {
  66. byte changes;
  67. changes=last_b ^ portb;
  68.  
  69. if(lastb == portb)
  70. interrupciones=TRUE;
  71. else
  72. {
  73. interrupciones=FALSE;
  74. }
  75. last_b=portb;
  76. lastb=portb;
  77.    if ( bit_test(changes,4) && !bit_test(last_b,4) )
  78.    {
  79.    while(!input(PIN_B4))
  80.       {
  81.       }
  82.       delay_ms(50);
  83.       if(interrupciones==FALSE)
  84.       {
  85.       resetLCD();
  86.       lcd_putc("Sentido\nGiro");
  87.       }
  88.       flagOK=FALSE;
  89.       flagVelocidad=FALSE;
  90.       flagDistancia=FALSE;
  91.       flagSentido=TRUE;
  92.       if((++punteroSentido) == 3)
  93.       punteroSentido=1;
  94.    }
  95.    
  96.    else if( bit_test(changes,5) && !bit_test(last_b,5) )
  97.    {
  98.    while(!input(PIN_B5))
  99.       {
  100.       }
  101.       delay_ms(50);
  102.    }
  103.    
  104.    else if ( bit_test(changes,6) && !bit_test(last_b,6) )
  105.    {
  106.    while(!input(PIN_B6))
  107.       {
  108.       }
  109.       delay_ms(50);
  110.       if(interrupciones==FALSE)
  111.       {
  112.       resetLCD();
  113.       lcd_putc("Ingrese\nPasos");
  114.       }
  115.       flagOK=TRUE;
  116.       flagVelocidad=FALSE;
  117.       flagDistancia=TRUE;
  118.       flagSentido=FALSE;
  119.       if((punteroDistancia++) == 5)
  120.       punteroDistancia=1;
  121.    }
  122.    
  123.    else if ( bit_test(changes,7) && !bit_test(last_b,7) )
  124.    {
  125.    while(!input(PIN_B7))
  126.       {
  127.       }
  128.       delay_ms(50);
  129.       if(interrupciones==FALSE)
  130.       {
  131.       resetLCD();
  132.       lcd_putc("Ingrese\nVel");
  133.       }
  134.       flagOK=FALSE;
  135.       flagVelocidad=TRUE;
  136.       flagDistancia=FALSE;
  137.       flagSentido=FALSE;
  138.       if((punteroVelocidad++) == 13)
  139.       punteroVelocidad=1;
  140.    }
  141. set_timer1(CARGAT1);  
  142. portb=0b11110001;
  143. }
  144.  
  145. void main(void)
  146. {
  147.    set_tris_b(0b11110001);
  148.    port_b_pullups(TRUE);
  149.    portb=0b11110001;
  150.    enable_interrupts(GLOBAL);
  151.    enable_interrupts(INT_EXT);
  152.    ext_int_edge( 0,H_TO_L );
  153.    enable_interrupts(INT_RB);
  154.    enable_interrupts(INT_TIMER1);
  155.    
  156.    setup_timer_1 (T1_INTERNAL|T1_DIV_BY_8);
  157.    set_tris_c(0);
  158.    set_tris_d(0);
  159.    lcd_init();
  160.    portd=0;
  161.    delay_ms(750);
  162.    lcd_gotoxy(1,1);
  163.    printf(lcd_putc,"Ingrese\nParametr");
  164.    set_timer1(CARGAT1);
  165.    last_b=0b11110001;
  166.  
  167.       while(1)
  168.       {
  169.       last_b=portb;
  170.          
  171.          if ((interrupciones==TRUE) && (flagDistancia==TRUE))
  172.          {
  173.          flagDistancia=0;
  174.             switch (punteroDistancia)
  175.             {
  176.                case 1:
  177.                {
  178.                cm=1;
  179.                }
  180.                break;
  181.                case 2:
  182.                {
  183.                cm=10;
  184.                }
  185.                break;
  186.                case 3:
  187.                {
  188.                cm=15;
  189.                }
  190.                break;
  191.                case 4:
  192.                {
  193.                cm=20;
  194.                }
  195.                break;
  196.                case 5:
  197.                {
  198.                cm=25;
  199.                }
  200.                break;  
  201.             }
  202.             resetLCD();
  203.             printf(lcd_putc,"Dis/Mot\n(cm)=%d ",cm);
  204.             NEW_PASOS=cm/0.0042;
  205.          }
  206.          if ((interrupciones==TRUE) && flagVelocidad==TRUE)
  207.          {
  208.          flagVelocidad=0;
  209.             switch (punteroVelocidad)
  210.             {
  211.                case 1:
  212.                {
  213.                CARGAT1=35000;
  214.                }
  215.                break;
  216.                case 2:
  217.                {
  218.                CARGAT1=37500;
  219.                }
  220.                break;
  221.                case 3:
  222.                {
  223.                CARGAT1=40000;
  224.                }
  225.                break;
  226.                case 4:
  227.                {
  228.                CARGAT1=42500;
  229.                }
  230.                break;
  231.                case 5:
  232.                {
  233.                CARGAT1=45000;
  234.                }
  235.                break;
  236.                case 6:
  237.                {
  238.                CARGAT1=47500;
  239.                }
  240.                break;
  241.                case 7:
  242.                {
  243.                CARGAT1=50000;
  244.                }
  245.                break;
  246.                case 8:
  247.                {
  248.                CARGAT1=52500;
  249.                }
  250.                break;
  251.                case 9:
  252.                {
  253.                CARGAT1=55000;
  254.                }
  255.                break;
  256.                case 10:
  257.                {
  258.                CARGAT1=57500;
  259.                }
  260.                break;  
  261.                case 11:
  262.                {
  263.                CARGAT1=60000;
  264.                }
  265.                break;
  266.                case 12:
  267.                {
  268.                CARGAT1=62500;
  269.                }
  270.                break;  
  271.                case 13:
  272.                {
  273.                CARGAT1=63200;
  274.                }
  275.                break;  
  276.             }
  277.             resetLCD();
  278.             calculo_Velocidad();
  279.          }
  280.          if ((interrupciones==TRUE) && (flagSentido==TRUE))
  281.          {
  282.          flagSentido=0;
  283.          resetLCD();
  284.             switch (punteroSentido)
  285.             {
  286.                case 1:
  287.                {
  288.                lcd_putc("Giro    \nHorario ");
  289.                }
  290.                break;
  291.                case 2:
  292.                {
  293.                lcd_putc("Giro    \nAntiHor.");
  294.                }
  295.                break;
  296.             }  
  297.          }
  298.          
  299.             if (flagOK)
  300.             {
  301.             if(punteroSentido==1)
  302.             secuencia_PCHorario();
  303.             else if(punteroSentido==2)
  304.             secuencia_PCAntihorario();
  305.             else
  306.             secuencia_PCHorario();
  307.             if(PASOS==0)                        //Estos son 5.000 pasos (en 1/2 paso)y un recorrido de 25.1 cm con mi unipolar
  308.             {
  309.             disable_interrupts(INT_TIMER1);
  310.             PASOS=(unsigned long) NEW_PASOS;
  311.             portc=0;
  312.             delay_ms(1000);                     //Original 200.
  313.             lcd_putc("\f");
  314.             printf(lcd_putc,"PASOS=\n%lu",PASOS);
  315.             enable_interrupts(INT_TIMER1);
  316.             set_timer1(CARGAT1);
  317.             }
  318.             }      
  319.       }
  320. }
  321.  
  322. void secuencia_PCHorario(void)
  323.    {
  324.    if(PUNTERO==4)
  325.    {
  326.    PUNTERO=0;
  327.    }
  328.       switch(PUNTERO)
  329.       {
  330.       case 0:
  331.       {
  332.       portc=0b11000000;
  333.       }
  334.       break;
  335.       case 1:
  336.       {
  337.       portc=0b01100000;
  338.       }
  339.       break;
  340.       case 2:
  341.       {
  342.       portc=0b00110000;
  343.       }
  344.       break;
  345.       case 3:
  346.       {
  347.       portc=0b10010000;
  348.       }
  349.       }
  350.    }
  351.    
  352. void secuencia_PCAntihorario(void)
  353.    {
  354.    if(PUNTERO==4)
  355.    {
  356.    PUNTERO=0;
  357.    }
  358.       switch(PUNTERO)
  359.       {
  360.       case 0:
  361.       {
  362.       portc=0b00110000;
  363.       }
  364.       break;
  365.       case 1:
  366.       {
  367.       portc=0b01100000;
  368.       }
  369.       break;
  370.       case 2:
  371.       {
  372.       portc=0b11000000;
  373.       }
  374.       break;
  375.       case 3:
  376.       {
  377.       portc=0b10010000;
  378.       }
  379.       }
  380.    }
  381.    
  382. void resetLCD(void)
  383.    {
  384.    lcd_putc("\f");
  385.    lcd_gotoxy(1,1);
  386.    delay_ms(50);
  387.    }
  388.    
  389. void calculo_Velocidad(void)
  390.    {
  391.    TIEMPO =(65535 - CARGAT1)/2;
  392.    TIEMPO =(TIEMPO * 8)* VEL_CRYSTAL;
  393.    PPS = 1/TIEMPO;
  394.    printf(lcd_putc,"Vel/Mot\npps=%lu ",(unsigned long)PPS);
  395.    }
En línea

Desconectado AngelGris

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 2480
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #1 en: 15 de Enero de 2011, 12:23:14 »
  Antes de activar las interrupciones te conviene borrar el flag por las dudas. Y siempre activa la interrupción global en último momento. También en el caso de la interrupción por cambio de los pines de RB, para que desaparezca la condición de cambio hay que leer el puerto.

  No sé como será en CCS para borrar los flag de interrupción, en HiTech basta con hacer RBIF = 0.

Código: C
  1. .........
  2. .........
  3.  
  4.   RBIF = 0;  //borro el flag para asegurarme que no entre erroneamente en la interrupcion
  5.   enable_interrupt (INT_RB); // habilito la interrupcion por cambio de estado
  6.   T1IF = 0;  / borro el flag del timer1
  7.   enable_interrupt (INT_TMR1);
  8.  
  9.   enable_interrupt (GLOBAL); //por ultimo habilitas las interrupciones globalmente
En línea
De vez en cuando la vida
nos besa en la boca
y a colores se despliega
como un atlas

Desconectado ppyote

  • Colaborador
  • PIC24F
  • *****
  • Mensajes: 929
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #2 en: 15 de Enero de 2011, 14:28:16 »
creo que la forma de hacerlo en ccs es con clear_interrupt(int_rb);
En línea
PPyote... siempre estareis en mi corazon.... Te quiero Hermano...

Desconectado jeremylf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1341
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #3 en: 15 de Enero de 2011, 15:26:32 »
Primero configura todo y luego activas la interrupciones globales alfinal (antes del while). Pon el delay al iniciar el programa antes dehacer cualquier cosa... vamos testea..

Salu2
En línea

Desconectado CarloS_32

  • PIC10
  • *
  • Mensajes: 27
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #4 en: 15 de Enero de 2011, 16:17:41 »
Cita de: AngelGris en 15 de Enero de 2011, 12:23:14
Antes de activar las interrupciones te conviene borrar el flag por las dudas. Y siempre activa la interrupción global en último momento. También en el caso de la interrupción por cambio de los pines de RB, para que desaparezca la condición de cambio hay que leer el puerto.
No sé como será en CCS para borrar los flag de interrupción, en HiTech basta con hacer RBIF = 0.

Gracias a todos por las respuestas..Angelgris lo de los flags no ha funcionado pero si esto ultimo de leer el puerto antes de activar la interrupción..al menos en el simulador..me ha quedado asi y esta es la forma en que funciona sin problemas

Código: CSS
  1. #include <16f877a.h>
  2. #fuses HS,NOPROTECT,NOWDT,PUT,NOLVP,BROWNOUT
  3. #use delay(clock=20M)
  4. #include <flex_lcd.c>
  5. #byte portb=6
  6. #byte portc=7
  7. #byte portd=8
  8. #use standard_io(b)
  9. #use fast_io(c)
  10. #use fast_io(d)
  11. #define VEL_CRYSTAL 0.000000200
  12. #bit RBIF=0x0B.0
  13.  
  14. boolean flagOK=FALSE,flagDistancia=FALSE,flagVelocidad=FALSE,flagSentido=FALSE;
  15. int punteroDistancia=0,punteroVelocidad=0,punteroSentido=0,interrupciones=0,last_b,lastb=0b11110001,PUNTERO=0,cm=0;
  16. unsigned long PASOS=300,CARGAT1=45000;
  17. float NEW_PASOS=0,TIEMPO=0,PPS=0;
  18.  
  19. void secuencia_PCHorario(void);
  20. void secuencia_PCAntihorario(void);
  21. void resetLCD(void);
  22. void calculo_Velocidad(void);
  23.  
  24. #INT_TIMER1
  25. RSI_tmr1()
  26. {
  27. set_timer1(CARGAT1);
  28. ++PUNTERO;
  29. if (PUNTERO==5)
  30. PUNTERO=0;
  31. --PASOS;
  32.  
  33. }
  34.  
  35. #INT_EXT
  36. RSI_intext()
  37. {
  38. while(!input(PIN_B0))
  39.    {
  40.    if(interrupciones==TRUE)
  41.       {
  42.       resetLCD();
  43.       lcd_putc("Ok!");
  44.       delay_ms(100);
  45.       }
  46.    }
  47.       if(interrupciones==TRUE)
  48.       {
  49.       flagOK=TRUE;
  50.       interrupciones=FALSE;
  51.       resetLCD();
  52.       PASOS=NEW_PASOS;
  53.       printf(lcd_putc,"PASOS=\n%lu",PASOS);
  54.       }
  55.       else if(interrupciones==FALSE)
  56.       {
  57.       flagOK=FALSE;
  58.       flagVelocidad=FALSE;
  59.       flagDistancia=FALSE;
  60.       flagSentido=FALSE;
  61.       }
  62. }
  63.  
  64. #INT_RB
  65. RSI_rb()
  66. {
  67. byte changes;
  68. changes=last_b ^ portb;
  69.  
  70. if(lastb == portb)
  71. interrupciones=TRUE;
  72. else
  73. {
  74. interrupciones=FALSE;
  75. }
  76. last_b=portb;
  77. lastb=portb;
  78.    if ( bit_test(changes,4) && !bit_test(last_b,4) )
  79.    {
  80.    while(!input(PIN_B4))
  81.       {
  82.       }
  83.       delay_ms(50);
  84.       if(interrupciones==FALSE)
  85.       {
  86.       resetLCD();
  87.       lcd_putc("Sentido\nGiro");
  88.       }
  89.       flagOK=FALSE;
  90.       flagVelocidad=FALSE;
  91.       flagDistancia=FALSE;
  92.       flagSentido=TRUE;
  93.       if((++punteroSentido) == 3)
  94.       punteroSentido=1;
  95.    }
  96.    
  97.    else if( bit_test(changes,5) && !bit_test(last_b,5) )
  98.    {
  99.    while(!input(PIN_B5))
  100.       {
  101.       }
  102.       delay_ms(50);
  103.    }
  104.    
  105.    else if ( bit_test(changes,6) && !bit_test(last_b,6) )
  106.    {
  107.    while(!input(PIN_B6))
  108.       {
  109.       }
  110.       delay_ms(50);
  111.       if(interrupciones==FALSE)
  112.       {
  113.       resetLCD();
  114.       lcd_putc("Ingrese\nPasos");
  115.       }
  116.       flagOK=FALSE;
  117.       flagVelocidad=FALSE;
  118.       flagDistancia=TRUE;
  119.       flagSentido=FALSE;
  120.       if((punteroDistancia++) == 5)
  121.       punteroDistancia=1;
  122.    }
  123.    
  124.    else if ( bit_test(changes,7) && !bit_test(last_b,7) )
  125.    {
  126.    while(!input(PIN_B7))
  127.       {
  128.       }
  129.       delay_ms(50);
  130.       if(interrupciones==FALSE)
  131.       {
  132.       resetLCD();
  133.       lcd_putc("Ingrese\nVel");
  134.       }
  135.       flagOK=FALSE;
  136.       flagVelocidad=TRUE;
  137.       flagDistancia=FALSE;
  138.       flagSentido=FALSE;
  139.       if((punteroVelocidad++) == 13)
  140.       punteroVelocidad=1;
  141.    }
  142. set_timer1(CARGAT1);  
  143. portb=0b11110001;
  144. }
  145.  
  146. void main(void)
  147. {
  148.    set_tris_b(0b11110001);
  149.    port_b_pullups(TRUE);
  150.    portb=0b11110001;
  151.    ext_int_edge( 0,H_TO_L );
  152.    setup_timer_1 (T1_INTERNAL|T1_DIV_BY_8);
  153.    set_tris_c(0);
  154.    set_tris_d(0);
  155.    lcd_init();
  156.    portd=0;
  157.    lcd_gotoxy(1,1);
  158.    printf(lcd_putc,"Ingrese\nParametr");
  159.    delay_ms(1000);
  160.    enable_interrupts(INT_EXT);
  161.    input(PIN_B1);             //Aqui se lee el puerto
  162.    enable_interrupts(INT_RB);
  163.    enable_interrupts(INT_TIMER1);
  164.    enable_interrupts(GLOBAL);
  165.    last_b=0b11110001;
  166.    set_timer1(CARGAT1);
  167.       while(1)
  168.       {
  169.       last_b=portb;
  170.          
  171.          if ((interrupciones==TRUE) && (flagDistancia==TRUE))
  172.          {
  173.          flagDistancia=0;
  174.             switch (punteroDistancia)
  175.             {
  176.                case 1:
  177.                {
  178.                cm=1;
  179.                }
  180.                break;
  181.                case 2:
  182.                {
  183.                cm=10;
  184.                }
  185.                break;
  186.                case 3:
  187.                {
  188.                cm=15;
  189.                }
  190.                break;
  191.                case 4:
  192.                {
  193.                cm=20;
  194.                }
  195.                break;
  196.                case 5:
  197.                {
  198.                cm=25;
  199.                }
  200.                break;  
  201.             }
  202.             resetLCD();
  203.             printf(lcd_putc,"Dis/Mot\n(cm)=%d ",cm);
  204.             NEW_PASOS=cm/0.0042;
  205.          }
  206.          if ((interrupciones==TRUE) && flagVelocidad==TRUE)
  207.          {
  208.          flagVelocidad=0;
  209.             switch (punteroVelocidad)
  210.             {
  211.                case 1:
  212.                {
  213.                CARGAT1=35000;
  214.                }
  215.                break;
  216.                case 2:
  217.                {
  218.                CARGAT1=37500;
  219.                }
  220.                break;
  221.                case 3:
  222.                {
  223.                CARGAT1=40000;
  224.                }
  225.                break;
  226.                case 4:
  227.                {
  228.                CARGAT1=42500;
  229.                }
  230.                break;
  231.                case 5:
  232.                {
  233.                CARGAT1=45000;
  234.                }
  235.                break;
  236.                case 6:
  237.                {
  238.                CARGAT1=47500;
  239.                }
  240.                break;
  241.                case 7:
  242.                {
  243.                CARGAT1=50000;
  244.                }
  245.                break;
  246.                case 8:
  247.                {
  248.                CARGAT1=52500;
  249.                }
  250.                break;
  251.                case 9:
  252.                {
  253.                CARGAT1=55000;
  254.                }
  255.                break;
  256.                case 10:
  257.                {
  258.                CARGAT1=57500;
  259.                }
  260.                break;  
  261.                case 11:
  262.                {
  263.                CARGAT1=60000;
  264.                }
  265.                break;
  266.                case 12:
  267.                {
  268.                CARGAT1=62500;
  269.                }
  270.                break;  
  271.                case 13:
  272.                {
  273.                CARGAT1=63200;
  274.                }
  275.                break;  
  276.             }
  277.             resetLCD();
  278.             calculo_Velocidad();
  279.          }
  280.          if ((interrupciones==TRUE) && (flagSentido==TRUE))
  281.          {
  282.          flagSentido=0;
  283.          resetLCD();
  284.             switch (punteroSentido)
  285.             {
  286.                case 1:
  287.                {
  288.                lcd_putc("Giro    \nHorario ");
  289.                }
  290.                break;
  291.                case 2:
  292.                {
  293.                lcd_putc("Giro    \nAntiHor.");
  294.                }
  295.                break;
  296.             }  
  297.          }
  298.          
  299.             if (flagOK)
  300.             {
  301.             if(punteroSentido==1)
  302.             secuencia_PCHorario();
  303.             else if(punteroSentido==2)
  304.             secuencia_PCAntihorario();
  305.             else
  306.             secuencia_PCHorario();
  307.             if(PASOS==0)                        //Estos son 5.000 pasos (en 1/2 paso)y un recorrido de 25.1 cm con mi unipolar
  308.             {
  309.             disable_interrupts(INT_TIMER1);
  310.             PASOS=(unsigned long) NEW_PASOS;
  311.             portc=0;
  312.             delay_ms(1000);                     //Original 200.
  313.             lcd_putc("\f");
  314.             printf(lcd_putc,"PASOS=\n%lu",PASOS);
  315.             enable_interrupts(INT_TIMER1);
  316.             set_timer1(CARGAT1);
  317.             }
  318.             }      
  319.       }
  320. }
  321.  
  322. void secuencia_PCHorario(void)
  323.    {
  324.    if(PUNTERO==4)
  325.    {
  326.    PUNTERO=0;
  327.    }
  328.       switch(PUNTERO)
  329.       {
  330.       case 0:
  331.       {
  332.       portc=0b11000000;
  333.       }
  334.       break;
  335.       case 1:
  336.       {
  337.       portc=0b01100000;
  338.       }
  339.       break;
  340.       case 2:
  341.       {
  342.       portc=0b00110000;
  343.       }
  344.       break;
  345.       case 3:
  346.       {
  347.       portc=0b10010000;
  348.       }
  349.       }
  350.    }
  351.    
  352. void secuencia_PCAntihorario(void)
  353.    {
  354.    if(PUNTERO==4)
  355.    {
  356.    PUNTERO=0;
  357.    }
  358.       switch(PUNTERO)
  359.       {
  360.       case 0:
  361.       {
  362.       portc=0b00110000;
  363.       }
  364.       break;
  365.       case 1:
  366.       {
  367.       portc=0b01100000;
  368.       }
  369.       break;
  370.       case 2:
  371.       {
  372.       portc=0b11000000;
  373.       }
  374.       break;
  375.       case 3:
  376.       {
  377.       portc=0b10010000;
  378.       }
  379.       }
  380.    }
  381.    
  382. void resetLCD(void)
  383.    {
  384.    lcd_putc("\f");
  385.    lcd_gotoxy(1,1);
  386.    delay_ms(50);
  387.    }
  388.    
  389. void calculo_Velocidad(void)
  390.    {
  391.    TIEMPO =(65535 - CARGAT1)/2;
  392.    TIEMPO =(TIEMPO * 8)* VEL_CRYSTAL;
  393.    PPS = 1/TIEMPO;
  394.    printf(lcd_putc,"Vel/Mot\npps=%lu ",(unsigned long)PPS);
  395.    }

Gracias
En línea

Desconectado CarloS_32

  • PIC10
  • *
  • Mensajes: 27
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #5 en: 15 de Enero de 2011, 16:31:23 »
Ahh otra cosa..me gustaria poder meterle un sleep cuando o bien no se ingrese ningun dato o bien el flagOK, (para no gastar pila al pepe ),que sirve para confirmar el dato, este a 0..nunca use la interrupción sleep ni como la usaria en este programa..creo que el pic puede despertarse cuando se dispara INT_RB pero no se si lo haria en el caso de INT_EXT..eso por un lado y otro problema que tengo es que cuando ingreso una nueva distancia por ende modifico los pasos me gustaria que volviera por decirlo asi al HOME o sea abortar los pasos q tenia cargado y regresar al punto de partida antes de cargar de nuevo los pasos ingresados..creo que esta dificil la solución y pensé en pegarle un sensor en el home (y que mientras vaya corriendo llevar una cuenta del numero de vueltas) tal vez sea lo mas facil..
En línea

Desconectado bmb

  • PIC18
  • ****
  • Mensajes: 423
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #6 en: 15 de Enero de 2011, 18:42:55 »
Hola Carlos_32, dándole un 'ojeada' a tu programa por encima, veo que tienes unas rutinas bien completas en al menos dos de las interrupciones incluyendo delays, llamadas al LCD y bucles while.  Me imagino la cantidad de advertencias (warnings) que te estará sacando el CCS al momento de compilar.  Creo que lo mejor sería que dentro de cada interrupción, solamente manejes las variables que sean necesarias y que dentro del código principal o alguna función, tomes las acciones del caso según el valor que tomen las variables en las interrupciones.

Saludos!
En línea

Desconectado CarloS_32

  • PIC10
  • *
  • Mensajes: 27
Re: Maldita #INT_RB disparandose al principio!!
« Respuesta #7 en: 15 de Enero de 2011, 19:44:51 »
Cita de: bmb en 15 de Enero de 2011, 18:42:55
Hola Carlos_32, dándole un 'ojeada' a tu programa por encima, veo que tienes unas rutinas bien completas en al menos dos de las interrupciones incluyendo delays, llamadas al LCD y bucles while.  Me imagino la cantidad de advertencias (warnings) que te estará sacando el CCS al momento de compilar.  Creo que lo mejor sería que dentro de cada interrupción, solamente manejes las variables que sean necesarias y que dentro del código principal o alguna función, tomes las acciones del caso según el valor que tomen las variables en las interrupciones.

Saludos!

Hola bmb si..esa es la idea (aunque el tiempo aqui no sea importante si por buena costumbre) no sabes la groseria que era mi anterior programa en eso..(que tambien funcionaba) tengo todas las variables que necesito ahi dentro y ademas son else-if por lo que si ejecuta uno no comprueba los demas y sale rápido eso no me interesa tanto mas bien lo del sleep.. pero de todas formas podria poner un while en lugar de el if en la parte del código que mueve el motor y asi esquivar todos los otros if que irian acumulando aun mas error entre paso y paso del motor..mi idea es que esto me quede lo mas corto posible y que me sirva para probar motores PAP bye
En línea
Páginas: [1]   Ir Arriba
« anterior próximo »
 

anything